Add types and refactor our imageFile helpers

* Extracts types to a definition file
* Adds TS_NODE_FILES env var to allow ts-node to pick up our definition
file

Author: rylnd

package.json

@@ -6,11 +6,11 @@
     "node": "9.4.x"
   },
   "scripts": {
-    "test": "mocha --exit",
+    "test": "TS_NODE_FILES=true mocha --exit",
     "build": "tsc && npm run build:assets",
     "build:assets": "cp -r {src,dist}/img",
     "dev": "concurrently --kill-others --prefix=name --names=server,eslint --prefix-colors=green,magenta \"npm run dev:server\" \"npm run dev:lint\"",
-    "dev:server": "onchange -i -k 'src/**/*.ts' -- ts-node test/server.ts",
+    "dev:server": "TS_NODE_FILES=true onchange -i -k 'src/**/*.ts' -- ts-node test/server.ts",
     "dev:lint": "onchange -i -k 'src/**/*.ts' -- tslint -t stylish 'src/**/*.ts'",
     "prepublishOnly": "npm run build"
   },

src/lib/imageFiles.ts

@@ -1,32 +1,23 @@
 import fs from 'fs';
 import path from 'path';
 
-const DEFAULT_IMAGE_DIR = path.join(__dirname, '..', 'img');
+const IMAGE_DIR = path.join(__dirname, '..', 'img');
 
-export const dirFor = (type, imageDir = DEFAULT_IMAGE_DIR) => {
-  if (type) {
-    return path.join(imageDir, type);
-  }
+const imageFiles: (path: string) => string[] = p =>
+  fs.readdirSync(p).filter(fileName => fileName.match(/\.png$/));
 
-  return imageDir;
-};
+const imageDir: (type: ImageType) => string = type =>
+  type ? path.join(IMAGE_DIR, type) : IMAGE_DIR;
 
-export const allNames = (type, imageDir = DEFAULT_IMAGE_DIR) => {
-  return fs
-    .readdirSync(dirFor(type, imageDir))
-    .filter(imageFileName => {
-      return imageFileName.match(/\.png/);
-    })
-    .map(imageFileName => {
-      return imageFileName.replace(/\.png/, '');
-    });
-};
+export const allNames: (type: ImageType) => string[] = type =>
+  imageFiles(imageDir(type)).map(imageFileName =>
+    imageFileName.replace(/\.png/, ''),
+  );
 
-export const allPaths = (type, imageDir = DEFAULT_IMAGE_DIR) => {
-  const dir = dirFor(type, imageDir);
-  return allNames(type, imageDir).map(name => path.join(dir, name + '.png'));
+export const allPaths: (type: ImageType) => string[] = type => {
+  const dir = imageDir(type);
+  return imageFiles(dir).map(file => path.join(dir, file));
 };
 
-export const pathFor = (type, fileName, imageDir = DEFAULT_IMAGE_DIR) => {
-  return path.join(dirFor(type, imageDir), fileName + '.png');
-};
+export const pathTo: (type: ImageType, name: string) => string = (type, name) =>
+  path.join(imageDir(type), name + '.png');

src/lib/potato.ts

@@ -2,13 +2,6 @@ import { sumAndDiff } from './hashingFunctions';
 import { allPaths } from './imageFiles';
 import SlotMachine from './slotMachine';
 
-export interface FaceParts {
-  color: string;
-  eyes: string;
-  nose: string;
-  mouth: string;
-}
-
 const colors = [
   '#81bef1',
   '#ad8bf2',
@@ -29,7 +22,7 @@ class Potato {
     private mouthMachine = new SlotMachine(allPaths('mouth'), sumAndDiff),
   ) {}
 
-  parts(string): FaceParts {
+  parts(string): Face {
     return {
       color: this.colorMachine.pull(string),
       eyes: this.eyesMachine.pull(string),

src/routes/index.ts

@@ -1,11 +1,11 @@
 import Router from 'express';
 import uuid from 'uuid';
 
-import { allNames, pathFor } from '../lib/imageFiles';
+import { allNames, pathTo } from '../lib/imageFiles';
 import { combine } from '../lib/imager';
 import potato from '../lib/potato';
 
-const partTypes = ['eyes', 'nose', 'mouth'];
+const imageTypes: ImageType[] = ['eyes', 'nose', 'mouth'];
 
 const router = Router();
 
@@ -16,13 +16,10 @@ const sendImage = ({ stdout, response }) => {
 };
 
 router.get('/list', (req, res) => {
-  const response = { face: {} };
+  const face = {};
+  imageTypes.forEach(type => (face[type] = allNames(type)));
 
-  partTypes.forEach(type => {
-    response.face[type] = allNames(type);
-  });
-
-  return res.set('Content-Type', 'application/json').send(response);
+  return res.set('Content-Type', 'application/json').send({ face });
 });
 
 router.get('/:size?/random', (req, res) => {
@@ -42,22 +39,20 @@ router.get('/:size?/:id', (req, res, next) => {
 });
 
 router.get('/face/:eyes/:nose/:mouth/:color/:size?', (req, res, next) => {
-  const faceParts = { color: '#' + req.params.color };
-
-  partTypes.forEach(type => {
-    const possibleFileNames = allNames(type);
-    const requestedFileName = req.params[type];
-
-    let fileName;
-    if (possibleFileNames.includes(requestedFileName)) {
-      fileName = requestedFileName;
-    } else if (requestedFileName === 'x') {
-      fileName = '';
-    } else {
-      fileName = possibleFileNames[0];
+  const faceParts = { color: `#${req.params.color}` };
+
+  imageTypes.forEach(type => {
+    const requestedName = req.params[type];
+    const names = allNames(type);
+    let name = names[0];
+
+    if (names.includes(requestedName)) {
+      name = requestedName;
+    } else if (requestedName === 'x') {
+      name = '';
     }
 
-    faceParts[type] = pathFor(type, fileName);
+    faceParts[type] = pathTo(type, name);
   });
 
   return combine(faceParts, req.params.size, (err, stdout) =>

src/types/index.d.ts

@@ -0,0 +1,9 @@
+type ImageType = 'eyes' | 'nose' | 'mouth';
+type FaceParts = ImageType | 'color';
+
+interface Face {
+  color: string;
+  eyes: string;
+  nose: string;
+  mouth: string;
+}

test/lib/imageFiles.test.ts

@@ -0,0 +1,17 @@
+import { expect } from 'chai';
+
+import { allNames, allPaths } from '../../src/lib/imageFiles';
+
+describe('allNames', () => {
+  it('lists all image names of a particular type', () => {
+    expect(allNames('eyes')).to.include.members(['eyes1', 'eyes2']);
+  });
+});
+
+describe('allPaths', () => {
+  it('lists all image paths of a particular type', () => {
+    const [mouthPath] = allPaths('mouth');
+
+    expect(mouthPath).to.match(/src\/img\/mouth\/mouth\d+.png/);
+  });
+});