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

package/src/commands/info.test.js

@@ -0,0 +1,415 @@
+import test from 'ava'
+import sinon from 'sinon'
+import esmock from 'esmock'
+
+test.beforeEach((t) => {
+  // Create sinon sandbox for mocking
+  t.context.sandbox = sinon.createSandbox()
+
+  // Create mock logger
+  t.context.mockLogger = {
+    info: t.context.sandbox.stub(),
+    error: t.context.sandbox.stub(),
+    debug: t.context.sandbox.stub(),
+    log: t.context.sandbox.stub(),
+    warn: t.context.sandbox.stub()
+  }
+
+  // Mock config
+  t.context.mockConfig = {
+    get: t.context.sandbox.stub().returns('./.quire-version')
+  }
+
+  // Mock testcwd helper
+  t.context.mockTestcwd = t.context.sandbox.stub()
+
+  // Mock execaCommand for external commands
+  t.context.mockExecaCommand = t.context.sandbox.stub()
+  t.context.mockExecaCommand.withArgs('quire --version').resolves({ stdout: '1.0.0-rc.33' })
+  t.context.mockExecaCommand.withArgs('npm --version').resolves({ stdout: '10.2.4' })
+
+  // Mock os module
+  t.context.mockOs = {
+    type: t.context.sandbox.stub().returns('Darwin'),
+    release: t.context.sandbox.stub().returns('23.0.0')
+  }
+
+  // Mock fs module
+  t.context.mockFs = {
+    readFileSync: t.context.sandbox.stub(),
+    writeFileSync: t.context.sandbox.stub(),
+    existsSync: t.context.sandbox.stub().returns(true)
+  }
+
+  // Default version file content
+  t.context.versionFileContent = JSON.stringify({
+    cli: '1.0.0-rc.33',
+    starter: 'https://github.com/thegetty/quire-starter-default'
+  })
+
+  // Default package.json content
+  t.context.packageJsonContent = JSON.stringify({
+    name: 'test-project',
+    version: '1.0.0'
+  })
+
+  // Setup default readFileSync behavior - stub returns different content based on file path
+  t.context.mockFs.readFileSync.callsFake((filePath, options) => {
+    if (filePath === './.quire-version') {
+      return t.context.versionFileContent
+    }
+    if (filePath === './package.json') {
+      return t.context.packageJsonContent
+    }
+    // For any other file, return empty string
+    return ''
+  })
+})
+
+test.afterEach.always((t) => {
+  // Restore all mocks
+  t.context.sandbox.restore()
+})
+
+test('info command should validate Quire project in preAction', async (t) => {
+  const { sandbox, mockLogger, mockTestcwd, mockConfig, mockExecaCommand, mockOs, mockFs } = t.context
+
+  const { default: InfoCommand } = await esmock('./info.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    'execa': {
+      execaCommand: mockExecaCommand
+    },
+    'node:os': mockOs,
+    'node:fs': mockFs
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new InfoCommand()
+  command.config = mockConfig
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  // Mock Commander.js command object
+  const mockCommand = {
+    name: () => 'info',
+    opts: () => ({})
+  }
+
+  // Call preAction
+  command.preAction(mockCommand)
+
+  t.true(mockTestcwd.called, 'testcwd should be called in preAction')
+  t.true(mockTestcwd.calledWith(mockCommand), 'testcwd should be called with command')
+})
+
+test('info command should display project version information', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+
+  const { default: InfoCommand } = await esmock('./info.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    'execa': {
+      execaCommand: mockExecaCommand
+    },
+    'node:os': mockOs,
+    'node:fs': mockFs
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new InfoCommand()
+  command.config = mockConfig
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  await command.action({}, {})
+
+  // Verify logger.info was called with project information
+  t.true(mockLogger.info.called, 'logger.info should be called')
+
+  // Check for project section header (uses current directory name)
+  const calls = mockLogger.info.getCalls()
+  const hasProjectInfo = calls.some((call) =>
+    call.args[0] && call.args[0].includes('[') && call.args[0].includes(']')
+  )
+  t.true(hasProjectInfo, 'should display project section')
+
+  // Check for quire-cli version in output
+  const hasCliVersion = calls.some((call) =>
+    call.args[0] && call.args[0].includes('quire-cli') && call.args[0].includes('1.0.0-rc.33')
+  )
+  t.true(hasCliVersion, 'should display quire-cli version')
+})
+
+test('info command should display system information with debug flag', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+
+  const { default: InfoCommand } = await esmock('./info.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    'execa': {
+      execaCommand: mockExecaCommand
+    },
+    'node:os': mockOs,
+    'node:fs': mockFs
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new InfoCommand()
+  command.config = mockConfig
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  await command.action({ debug: true }, {})
+
+  // Verify logger.info was called
+  t.true(mockLogger.info.called, 'logger.info should be called')
+
+  // Check for system section header
+  const calls = mockLogger.info.getCalls()
+  const hasSystemInfo = calls.some((call) =>
+    call.args[0] && call.args[0].includes('[System]')
+  )
+  t.true(hasSystemInfo, 'should display system section with debug flag')
+
+  // Check for node version in output (only shown with debug)
+  const hasNodeVersion = calls.some((call) =>
+    call.args[0] && call.args[0].includes('node')
+  )
+  t.true(hasNodeVersion, 'should display node version with debug flag')
+
+  // Check for npm version in output (only shown with debug)
+  const hasNpmVersion = calls.some((call) =>
+    call.args[0] && call.args[0].includes('npm')
+  )
+  t.true(hasNpmVersion, 'should display npm version with debug flag')
+})
+
+test('info command should hide system details without debug flag', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+
+  const { default: InfoCommand } = await esmock('./info.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    'execa': {
+      execaCommand: mockExecaCommand
+    },
+    'node:os': mockOs,
+    'node:fs': mockFs
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new InfoCommand()
+  command.config = mockConfig
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  await command.action({}, {})
+
+  // Verify logger.info was called
+  t.true(mockLogger.info.called, 'logger.info should be called')
+
+  // Check that system details are NOT shown without debug flag
+  const calls = mockLogger.info.getCalls()
+
+  // Node version should not appear in non-debug output
+  const hasNodeVersion = calls.some((call) =>
+    call.args[0] && call.args[0].toLowerCase().includes('node') && !call.args[0].includes('quire')
+  )
+  t.false(hasNodeVersion, 'should not display node version without debug flag')
+})
+
+test('info command should handle missing version file', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+
+  // Setup mockFs to throw error for missing version file (simulating file not found)
+  mockFs.readFileSync.callsFake((filePath, options) => {
+    if (filePath === './.quire-version') {
+      throw new Error('ENOENT: no such file')
+    }
+    if (filePath === './package.json') {
+      return t.context.packageJsonContent
+    }
+    return ''
+  })
+
+  const { default: InfoCommand } = await esmock('./info.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    'execa': {
+      execaCommand: mockExecaCommand
+    },
+    'node:os': mockOs,
+    'node:fs': mockFs
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new InfoCommand()
+  command.config = mockConfig
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  await command.action({}, {})
+
+  // Verify warning was logged about old version
+  t.true(mockLogger.warn.called, 'logger.warn should be called for missing version file')
+  t.true(
+    mockLogger.warn.calledWith(sinon.match(/prior to version 1.0.0.rc-8/)),
+    'should warn about old project version'
+  )
+
+  // Verify version file was created
+  t.true(mockFs.writeFileSync.called, 'writeFileSync should be called to create version file')
+})
+
+test('info command should handle malformed version file', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+
+  // Setup mockFs to return malformed JSON (simulating corrupted file)
+  mockFs.readFileSync.callsFake((filePath, options) => {
+    if (filePath === './.quire-version') {
+      return 'invalid json{'
+    }
+    if (filePath === './package.json') {
+      return t.context.packageJsonContent
+    }
+    return ''
+  })
+
+  const { default: InfoCommand } = await esmock('./info.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    'execa': {
+      execaCommand: mockExecaCommand
+    },
+    'node:os': mockOs,
+    'node:fs': mockFs
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new InfoCommand()
+  command.config = mockConfig
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  await command.action({}, {})
+
+  // Verify warning was logged
+  t.true(mockLogger.warn.called, 'logger.warn should be called for malformed version file')
+
+  // Verify version file was overwritten with valid JSON
+  t.true(mockFs.writeFileSync.called, 'writeFileSync should be called to fix malformed version file')
+
+  // Check that the content written is valid JSON
+  const writeCall = mockFs.writeFileSync.getCall(0)
+  if (writeCall) {
+    const writtenContent = writeCall.args[1]
+    t.notThrows(() => JSON.parse(writtenContent), 'written content should be valid JSON')
+  }
+})
+
+test('info command should read quire-11ty version from package.json', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+
+  // Override package.json to have specific version
+  mockFs.readFileSync.callsFake((filePath, options) => {
+    if (filePath === './.quire-version') {
+      return t.context.versionFileContent
+    }
+    if (filePath === './package.json') {
+      return JSON.stringify({
+        name: 'test-project',
+        version: '2.5.3'
+      })
+    }
+    return ''
+  })
+
+  const { default: InfoCommand } = await esmock('./info.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    'execa': {
+      execaCommand: mockExecaCommand
+    },
+    'node:os': mockOs,
+    'node:fs': mockFs
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new InfoCommand()
+  command.config = mockConfig
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  await command.action({}, {})
+
+  // Verify logger.info was called
+  t.true(mockLogger.info.called, 'logger.info should be called')
+
+  // Check for quire-11ty version from package.json
+  const calls = mockLogger.info.getCalls()
+  const hasEleventyVersion = calls.some((call) =>
+    call.args[0] && call.args[0].includes('quire-11ty') && call.args[0].includes('2.5.3')
+  )
+  t.true(hasEleventyVersion, 'should display quire-11ty version from package.json')
+})
+
+test('info command should log debug information when debug flag is set', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+
+  const mockDebug = sandbox.stub()
+
+  const { default: InfoCommand } = await esmock('./info.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    'execa': {
+      execaCommand: mockExecaCommand
+    },
+    'node:os': mockOs,
+    'node:fs': mockFs
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new InfoCommand()
+  command.config = mockConfig
+  command.logger = mockLogger
+  command.debug = mockDebug
+
+  await command.action({ debug: true }, {})
+
+  // Verify debug was called
+  t.true(mockDebug.called, 'debug should be called with debug flag')
+  t.true(mockDebug.calledWith('called with options %O', { debug: true }))
+})

package/src/commands/pdf.js

@@ -1,50 +1,13 @@
-import { paths, projectRoot  } from '#lib/11ty/index.js'
 import Command from '#src/Command.js'
-import fs from 'fs-extra'
-import libPdf from '#lib/pdf/index.js'
+import { withOutputModes } from '#lib/commander/index.js'
+import paths, { hasSiteOutput } from '#lib/project/index.js'
+import eleventy from '#lib/11ty/index.js'
+import generatePdf, { ENGINES } from '#lib/pdf/index.js'
 import open from 'open'
 import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-import yaml from 'js-yaml'
-
-/**
- * @function loadConfig(path) - loads and validates quire config, returns an empty object if not found
- *  
- * @param {path} string - file path to config file
- * 
- * @return {Object|undefined} User configuration object or undefined
- * 
- * @todo consider hardcoding a version check against .quire / project's package.json ver
- */
-async function loadConfig(configPath) {
-  if (!fs.existsSync(configPath)) {
-    return undefined
-  }
-
-  const data = fs.readFileSync(configPath)
-  let config = yaml.load(data)
-
-  // NB: Schemas and validators are specific to the 11ty version of the project being built
-  const schemaPath = path.join(projectRoot,'_plugins','schemas','config.json')
-  const validatorPath = path.join(projectRoot, '_plugins', 'globalData', 'validator.js')
-
-  if (fs.existsSync(schemaPath) && fs.existsSync(validatorPath)) {
-
-    const { validateUserConfig } = await import(pathToFileURL(validatorPath))
-  
-    const schemaJSON = fs.readFileSync(schemaPath)
-    const schema = JSON.parse(schemaJSON)
-
-    try {
-      config = validateUserConfig('config', config, { config: schema })
-    } catch (error) {
-      console.error(error)
-      process.exit(1)
-    }
-  }
-
-  return config
-}
+import reporter from '#lib/reporter/index.js'
+import testcwd from '#helpers/test-cwd.js'
+import { MissingBuildOutputError } from '#src/errors/index.js'
 
 /**
  * Quire CLI `pdf` Command
@@ -55,66 +18,77 @@ async function loadConfig(configPath) {
  * @extends    {Command}
  */
 export default class PDFCommand extends Command {
-  static definition = {
+  static definition = withOutputModes({
     name: 'pdf',
     description: 'Generate publication PDF',
-    summary: 'run build pdf',
+    summary: 'generate print-ready PDF',
+    docsLink: 'quire-commands/#output-files',
+    helpText: `
+Examples:
+  quire pdf                       Generate PDF using default engine
+  quire pdf --engine prince       Generate PDF using PrinceXML
+  quire pdf --build               Build site first, then generate PDF
+  quire pdf --output my-book.pdf  Generate PDF with custom output path
+  quire pdf --verbose             Generate with detailed progress
+`,
     version: '1.0.0',
-    args: [
-    ],
     options: [
+      [ '--build', 'run build first if output is missing' ],
+      [ '--open', 'open PDF in default application' ],
+      [ '-o, --output <path>', 'output file path (default: from project config)' ],
       [
-        '--lib <module>', 'use the specified pdf module', 'pagedjs',
-        { choices: ['pagedjs', 'prince'], default: 'pagedjs' }
+        '--engine <name>', 'PDF engine to use (default: from config or pagedjs)',
+        { choices: ENGINES }
+      ],
+      [
+        '--lib <name>', 'deprecated alias for --engine option',
+        { hidden: true, choices: ENGINES, conflicts: 'engine' }
       ],
-      [ '--open', 'open PDF in default application' ],
-      [ '--debug', 'run build with debug output to console' ],
     ],
-  }
+  })
 
   constructor() {
     super(PDFCommand.definition)
   }
 
   async action(options, command) {
-    if (options.debug) {
-      console.debug('[CLI] Command \'%s\' called with options %o', this.name(), options)
-    }
-
-    const publicationInput = path.join(projectRoot, paths.output, 'pdf.html')
-    const coversInput = path.join(projectRoot, paths.output, 'pdf-covers.html')
-
-    const quireConfig = await loadConfig(path.join(projectRoot,'content','_data','config.yaml'))
-
-    if (quireConfig === undefined) {
-      console.error(`[quire pdf]: ERROR Unable to find a configuration file at ${path.join(projectRoot,'content','_data','config.yaml')}\nIs the command being run in a quire project?`)
-      process.exit(1)
+    this.debug('called with options %O', options)
+    /**
+     * Configure reporter for this command
+     * reporter lifecycle (start/succeed/fail) is handled by the façade,
+     * not by the command.
+     */
+    reporter.configure({ quiet: options.quiet, verbose: options.verbose })
+
+    // Resolve engine: CLI --engine > deprecated --lib > config pdfEngine > 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('pdfEngine') || 'pagedjs'
+      }
     }
 
-    if (!fs.existsSync(publicationInput)) {
-      console.error(`[quire pdf]: ERROR Unable to find PDF input at ${publicationInput}\nPlease first run the 'quire build' command.`)
-      process.exit(1)
+    // Run build first if --build flag is set and output is missing
+    if (options.build && !hasSiteOutput()) {
+      this.debug('running build before pdf generation')
+      reporter.start('Building site...', { showElapsed: true })
+      await eleventy.build({ debug: options.debug })
+      reporter.succeed('Build complete')
     }
 
-    const output = quireConfig.pdf !== undefined
-      ? path.join(paths.output, quireConfig.pdf.outputDir, `${quireConfig.pdf.filename}.pdf`)
-      : path.join(projectRoot, `${options.lib}.pdf`)
-
-    const pdfLib = await libPdf(options.lib, { ...options, pdfConfig: quireConfig.pdf })
-    await pdfLib(publicationInput, coversInput, output)
+    // Generate PDF - façade handles validation, progress, and errors
+    const pdfOptions = { ...options, lib: options.engine }
+    const output = await generatePdf(pdfOptions)
 
-    try {
-      if (fs.existsSync(output) && options.open) open(output)
-    } catch (error) {
-      console.error(`[quire pdf]: ERROR`,error)
-      process.exit(1)
+    if (options.open) {
+      open(output)
     }
   }
 
-  /**
-   * @todo test if build has already be run and output can be reused
-   */
-  preAction(command) {
-    // testcwd(command)
+  preAction(thisCommand, actionCommand) {
+    testcwd(thisCommand)
   }
 }