start some tests

Author: lancejpollard

.gitignore

@@ -38,3 +38,5 @@ next-env.d.ts
 .env
 
 /host
+
+/test/hold

.npmignore

@@ -17,3 +17,4 @@ tsconfig.json
 .dockerignore
 Dockerfile*
 .gitattributes
+/test/hold

code/cli/error.ts

@@ -1,5 +1,5 @@
 import Kink, { KinkList } from '@termsurf/kink'
-import { logWithSpace } from '../shared/logger'
+import { logWithSpace } from '../shared/logger.js'
 import { makeBaseKinkText, makeKinkText } from '@termsurf/kink-text'
 
 export function logError(kink) {

code/cli/logging.ts

@@ -1,12 +1,11 @@
 import stripAnsi from 'strip-ansi'
 import tint, { Tint } from '@termsurf/tint-text'
 import ora from 'ora'
-import chalk from 'chalk'
-import { log, logWithSpace } from '../shared/logger'
+import { log, logWithSpace } from '../shared/logger.js'
 
 const M: Tint = { tone: 'magenta' }
 const C: Tint = { tone: 'cyan' }
-const B: Tint = { tone: 'gray' }
+const B: Tint = { tone: 'white' }
 const G: Tint = { tone: 'green' }
 const R: Tint = { tone: 'red' }
 
@@ -26,7 +25,8 @@ export function logStart(text: string, color = true) {
 }
 
 export function logSpinnerWithSpace(text: string) {
-  return ora({ prefixText: '\n ', suffixText: '\n' }).start(text)
+  // return ora({ prefixText: '\n ', suffixText: '\n' }).start(text)
+  return ora().start(text)
 }
 
 export function logSpinner(text: string) {
@@ -47,6 +47,20 @@ export function logOutput(text: string, color = true) {
   }
 }
 
+export function logOutputError(text: string, color = true) {
+  if (!text) {
+    return
+  }
+
+  if (color) {
+    logWithSpace(
+      `  ${tint('link <', B)}${tint(text, R)}${tint('>', B)}`,
+    )
+  } else {
+    log(text)
+  }
+}
+
 export function renderProgress(text: string, color = true) {
   if (color) {
     return `${tint('note <', B)}${tint(text, C)}${tint('>', B)}`

code/cli/parse.ts

@@ -1,5 +1,6 @@
 import { Form, FormLink } from '@termsurf/form'
 import { Input, Link, Value } from './type'
+import _ from 'lodash'
 
 export function transferInput(source, map: Record<string, Link>) {
   const out: Record<string, Value | Array<Value>> = {}

code/cli/task.ts

@@ -9,7 +9,10 @@ import {
 } from '../node/document.js'
 import { convertFontWithFontForge } from '../node/font.js'
 import { convertVideoWithFfmpeg } from '../node/video.js'
-import { convertImageWithImageMagick } from '../node/image.js'
+import {
+  convertImageWithImageMagick,
+  verifyImageWithImageMagick,
+} from '../node/image.js'
 import {
   build_command_to_convert_document_with_calibre,
   build_command_to_convert_document_with_libre_office,
@@ -19,7 +22,12 @@ import {
   build_command_to_process_image,
 } from '../shared/type/source/index.js'
 import { Form } from '@termsurf/form'
-import { BuildFormatInputOutputModel, Task } from '../shared/index.js'
+import {
+  BuildFormatInputOutputModel,
+  IMAGE_MAGICK_FORMAT,
+  ImageMagickFormat,
+  Task,
+} from '../shared/index.js'
 import kink from '../shared/kink.js'
 import {
   useConvertDocumentWithCalibre,
@@ -29,7 +37,12 @@ import {
   useConvertImageWithImageMagick,
   useConvertVideoWithFfmpeg,
 } from '../node/call/convert.js'
-import { logOutput, logStart, renderProgress } from './logging.js'
+import {
+  logOutput,
+  logOutputError,
+  logStart,
+  renderProgress,
+} from './logging.js'
 import {
   buildCliOptions,
   buildInputMapping,
@@ -48,6 +61,15 @@ export const CONVERT_KEY: Record<string, Link> = {
   // -l color -l plain
 }
 
+export const INPUT_KEY: Record<string, Link> = {
+  i: { line: ['input', 'file', 'path'] },
+  I: { line: ['input', 'format'], need: false },
+  b: { line: ['input', 'directory', 'path'], need: false },
+  h: { line: ['help'], need: false, like: 'boolean' },
+  l: { line: ['log'], need: false, like: 'string' }, // -l json to output json
+  // -l color -l plain
+}
+
 export async function call(task: Task, source) {
   switch (task) {
     case 'convert': {
@@ -127,12 +149,19 @@ export async function call(task: Task, source) {
         if (source.help) {
           return showHelpForConvert(form)
         }
-        const spinner = logStart(`Converting image...`, isColor)
-        const input = transferInput(source, buildInputMapping(form))
-        const out = await convertImageWithImageMagick(input)
-        spinner?.stop()
-        logOutput(out, isColor)
-        return
+        let spinner
+
+        try {
+          spinner = logStart(`Converting image...`, isColor)
+          const input = transferInput(source, buildInputMapping(form))
+          const out = await convertImageWithImageMagick(input)
+          spinner?.stop()
+          logOutput(out, isColor)
+          return
+        } catch (e) {
+          spinner?.stop()
+          throw e
+        }
       }
 
       if (
@@ -181,6 +210,24 @@ export async function call(task: Task, source) {
     case 'decompress': {
       break
     }
+    case 'verify': {
+      const base = transferInput(source, INPUT_KEY)
+      if (
+        'input' in base &&
+        typeof base.input === 'object' &&
+        'format' in base.input &&
+        IMAGE_MAGICK_FORMAT.includes(
+          base.input.format as ImageMagickFormat,
+        )
+      ) {
+        if (await verifyImageWithImageMagick(base)) {
+          logOutput(`Image is a ${base.input.format}.`)
+        } else {
+          logOutputError(`Image is not ${base.input.format}.`)
+        }
+        return
+      }
+    }
   }
 
   throw kink('task_not_implemented', {

code/node/command.ts

@@ -1,13 +1,21 @@
 import bytes from 'bytes'
 import child_process from 'child_process'
-import { Command, CommandCall, CommandName } from '../shared/index.js'
+import {
+  Command,
+  CommandCall,
+  CommandName,
+  IMAGE_MAGICK_FORMAT,
+} from '../shared/index.js'
 import kink from '../shared/kink.js'
 import { ChildProcessError, Message, exec } from './process.js'
 import Kink from '@termsurf/kink'
+import _ from 'lodash'
 
 export type CommandHandle = (cmd: CommandCall) => Promise<string | void>
 
 export const COMMAND_HANDLE: Record<CommandName, CommandHandle> = {
+  patool: handlePatoolCommand,
+  identify: handleIdentifyCommand,
   ffmpeg: handleFfmpegCommand,
   black: handleBlackCommand,
   asmfmt: handleAsmfmtCommand,
@@ -86,6 +94,10 @@ export async function handleGifsicleCommand(cmd: CommandCall) {
   return await exec(cmd.join(' '))
 }
 
+export async function handlePatoolCommand(cmd: CommandCall) {
+  return await exec(cmd.join(' '))
+}
+
 export async function handleBlackCommand(cmd: CommandCall) {
   return await exec(cmd.join(' '))
 }
@@ -106,7 +118,7 @@ export async function handleConvertCommand(cmd: CommandCall) {
       if (e.data.stderr) {
         if (e.data.stderr.match(/^convert: unable to open image/i)) {
           // throw new Kink
-          throw new Error(`Cannot process image`)
+          throw new Error(`Cannot process image.`)
         }
       }
     } else {
@@ -140,6 +152,16 @@ export async function handleCommand(cmd: Command) {
   return await handle(cmd.list)
 }
 
+export async function handleIdentifyCommand(cmd: CommandCall) {
+  const text = await exec(cmd.join(' '))
+  const pattern = new RegExp(`^([^\\s]+)\\s+(\\w+)`, 'i')
+  text.match(pattern)
+  return {
+    path: RegExp.$1,
+    format: _.snakeCase(RegExp.$2),
+  }
+}
+
 export async function handleJavaCommand(cmd: CommandCall) {
   return await exec(cmd.join(' '))
 }

code/node/image.ts

@@ -2,13 +2,15 @@ import _ from 'lodash'
 import {
   BuildCommandToConvertAiToSvgWithInkscapeModel,
   BuildCommandToProcessImageModel,
+  IMAGE_MAGICK_FORMAT,
   IMAGE_MAGICK_INPUT_FORMAT,
   IMAGE_MAGICK_OUTPUT_FORMAT,
   INKSCAPE_EXPORT_FORMAT,
 } from '../shared/type/index.js'
 import {
   buildCommandToConvertAIToSVGWithInkscape,
   buildCommandToProcessImage,
+  buildCommandToVerifyImageWithImageMagick,
 } from '../shared/index.js'
 import {
   buildUseConvert,
@@ -70,3 +72,37 @@ export async function convertImageWithInkscape(source) {
   }
   return input.output.file.path
 }
+
+export async function verifyImageWithImageMagick(source) {
+  const [cmd] = await buildCommandToVerifyImageWithImageMagick(source)
+  if (cmd) {
+    const data = await handleCommand(cmd)
+    if (
+      IMAGE_MAGICK_FORMAT.includes(data.format) &&
+      isFormatMatch(data.format, source.input.format)
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+const IMAGEMAGICK_FORMAT_VARIANT_NAME: Record<string, Array<string>> = {
+  jpeg: ['jpg'],
+  jpg: ['jpeg'],
+}
+
+function isFormatMatch(a: string, b: string) {
+  if (a === b) {
+    return true
+  }
+  const v = IMAGEMAGICK_FORMAT_VARIANT_NAME[a]
+  if (v) {
+    for (const x of v) {
+      if (x === b) {
+        return true
+      }
+    }
+  }
+  return false
+}

code/shared/command.ts

@@ -36,6 +36,7 @@ export const COMMAND_NAME = [
   'unoconv',
   'gifsicle',
   'patool',
+  'identify',
 ] as const
 
 export type CommandName = (typeof COMMAND_NAME)[number]
@@ -65,6 +66,7 @@ export const COMMAND: Record<CommandName, Array<string> | undefined> = {
   rustc: ['rustc'],
   rustfmt: ['rustfmt'],
   gifsicle: ['gifsicle'],
+  identify: ['identify'],
   rubocop: ['rubocop'],
   shfmt: ['shfmt'],
   zip: ['zip'],

code/shared/image.ts

@@ -277,6 +277,14 @@ export async function buildCommandToConvertAIToSVGWithInkscape(
   return [cmd]
 }
 
+export async function buildCommandToVerifyImageWithImageMagick(input) {
+  const cmd = getCommand(`identify`)
+
+  cmd.list.push(`"${input.input.file.path}"`)
+
+  return [cmd]
+}
+
 export type ExifMetadata = { name: string; bond: string | number }
 
 export function parseImageMetadataFromExifTool(lines: Array<string>) {