diff --git a/.babelrc b/.babelrc new file mode 100644 index 0000000..e9bd8f8 --- /dev/null +++ b/.babelrc @@ -0,0 +1,10 @@ +{ + "presets": [ + "es2015" + ], + "plugins": [ + "transform-async-to-generator", + "source-map-support" + ], + "sourceMaps": "inline" +} diff --git a/.eslintignore b/.eslintignore new file mode 100644 index 0000000..5820778 --- /dev/null +++ b/.eslintignore @@ -0,0 +1,2 @@ +dist +benchmark diff --git a/.eslintrc.js b/.eslintrc similarity index 70% rename from .eslintrc.js rename to .eslintrc index ce279f0..9fe82c7 100644 --- a/.eslintrc.js +++ b/.eslintrc @@ -1,13 +1,21 @@ -module.exports = { +{ "env": { "es6": true, "node": true }, "extends": "eslint:recommended", "parserOptions": { - "sourceType": "module" + "sourceType": "module", + "ecmaVersion": 2017 }, "rules": { + "prefer-destructuring": ["error", { + "array": true, + "object": true + }, { + "enforceForRenamedProperties": false + } + ], "indent": [ "error", 4 @@ -33,4 +41,4 @@ module.exports = { "as-needed" ] } -}; +} diff --git a/.travis.yml b/.travis.yml index e8ef988..593d567 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,7 +6,12 @@ os: - linux - osx osx_image: xcode8 -script: 'npm test' -cache: - directories: - - node_modules +install: + - npm install + - npm run lint + - npm run build +script: + - npm run test-build +# cache: +# directories: +# - node_modules diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..4dbdc26 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,12 @@ +FROM node:4-alpine +RUN apk --no-cache add perl + +ADD package.json /app/package.json +RUN cd /app && npm install + +ADD . /app +WORKDIR /app +RUN npm install + +# ENV NODE_ENV production +CMD ["npm", "run", "build"] diff --git a/README.md b/README.md index bc11a61..9cbf7dd 100644 --- a/README.md +++ b/README.md @@ -718,6 +718,17 @@ context.globalExiftoolConstructor = exiftool.ExiftoolProcess Otherwise, the context will use a stable version which it installs independently. +## Building + +The project is written with ES2017 (`async/await`) and built to be compatible +with lower Node.js versions using `Babel`. `npm run build` will build source +and test files. `npm run test-build` will run transpiled tests against +transpiled sources, whereas `npm t` will run raw tests against raw source files. + +The preset used for transpiling is `es2015`, but without +`transform-es2015-classes`, and with `transform-async-to-generator` and +`source-map-support`. + ## Metadata Metadata is awesome and although it can increase the file size, it preserves diff --git a/appveyor.yml b/appveyor.yml index 6699917..6f1f0d5 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -8,6 +8,9 @@ install: - ps: Install-Product node $env:nodejs_version # install modules - npm install + - npm run lint + # transpile + - npm run build # Post-install test scripts. test_script: @@ -15,7 +18,7 @@ test_script: - node --version - npm --version # run tests - - npm test + - npm run test-build # Don't actually build. build: off diff --git a/dist/src/begin-ready.js b/dist/src/begin-ready.js new file mode 100644 index 0000000..eb408dc --- /dev/null +++ b/dist/src/begin-ready.js @@ -0,0 +1,91 @@ +'use strict'; + +require('source-map-support/register'); + +var _require = require('stream'), + Transform = _require.Transform, + Writable = _require.Writable; + +var restream = require('restream'); + +var BEGIN_READY_RE = /{begin(\d+)}([\s\S]*){ready\1}/g; + +/** + * A transform stream which will mutate data from regex stream into an object + * with commandNumber and data. + * @return {Transfrom} A transform stream into which exiftool process stdout and + * stderr can be piped. It will push objects in form of { cn: commandNumber, d: data } + */ +function createBeginReadyMatchTransformStream() { + var ts = new Transform({ objectMode: true }); + // expecting data from RegexTransformStream with BEGIN_READY_RE + ts._transform = function (match, enc, next) { + var data = { + cn: match[1], + d: match[2].trim() + }; + next(null, data); + }; + return ts; +} + +/** + * A write stream which will maintain a map of commands which are waiting + * to be resolved, where keys are the corresponding resolve promise. The + * stream will expect input from BeginReady Transform Stream. + * @return {Writable} A write stream extended with `addToResolveMap` method. + * @see createBeginReadyTransformStream + */ +function createResolverWriteStream() { + var ws = new Writable({ + objectMode: true + }); + ws._resolveMap = {}; + ws.addToResolveMap = function (commandNumber, resolve) { + if (typeof commandNumber !== 'string') { + throw new Error('commandNumber argument must be a string'); + } + if (typeof resolve !== 'function') { + throw new Error('resolve argument must be a function'); + } + if (this._resolveMap[commandNumber]) { + throw new Error('Command with the same number is already expected'); + } + this._resolveMap[commandNumber] = resolve; + }; + ws._write = function (obj, enc, next) { + var commandNumber = obj.cn; + var data = obj.d; + var resolve = this._resolveMap[commandNumber]; + if (resolve) { + resolve(data); + delete this._resolveMap[commandNumber]; + next(); + } else { + next(new Error('Command with index ' + commandNumber + ' not found')); + } + }; + return ws; +} + +/** + * Setup a pipe from process std stream into resolve write stream + * through regex transform and begin-ready transform streams. + * @param {Readable} rs Readable stream (from exiftool process) + * @return {Writable} A Resolve transform stream. + */ +function setupResolveWriteStreamPipe(rs) { + var rts = restream(BEGIN_READY_RE); + var brmts = createBeginReadyMatchTransformStream(); + var rws = createResolverWriteStream(); + + return rs.pipe(rts).pipe(brmts).pipe(rws); +} + +module.exports = { + createBeginReadyMatchTransformStream: createBeginReadyMatchTransformStream, + createResolverWriteStream: createResolverWriteStream, + BEGIN_READY_RE: BEGIN_READY_RE, + setupResolveWriteStreamPipe: setupResolveWriteStreamPipe +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/src/execute-with-rs.js b/dist/src/execute-with-rs.js new file mode 100644 index 0000000..a64e0c9 --- /dev/null +++ b/dist/src/execute-with-rs.js @@ -0,0 +1,43 @@ +'use strict'; + +require('source-map-support/register'); + +var wrote = require('wrote'); + +var _require = require('stream'), + Readable = _require.Readable; + +/** + * Create temp file for rs, execute exiftool command, then erase file + * @param {Readable} rs a read stream + * @param {string[]} args Arguments + * @param {function} executeCommand function which is responsible for executing the command + */ + + +function executeWithRs(rs, args, executeCommand) { + if (!(rs instanceof Readable)) { + return Promise.reject(new Error('Please pass a readable stream')); + } + if (typeof executeCommand !== 'function') { + return Promise.reject(new Error('executeCommand must be a function')); + } + var ws = void 0; + return wrote() // temp file will be created + .then(function (res) { + ws = res; + rs.pipe(ws); + return executeCommand(ws.path, args); + }).then(function (res) { + return wrote.erase(ws).then(function () { + return res; + }); + }, function (err) { + return wrote.erase(ws).then(function () { + throw err; + }); + }); +} + +module.exports = executeWithRs; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/src/index.js b/dist/src/index.js new file mode 100644 index 0000000..b8f1e73 --- /dev/null +++ b/dist/src/index.js @@ -0,0 +1,318 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +require('source-map-support/register'); + +function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var EventEmitter = require('events'); +var lib = require('./lib'); +var beginReady = require('./begin-ready'); +var executeWithRs = require('./execute-with-rs'); + +var EXIFTOOL_PATH = 'exiftool'; + +var events = { + OPEN: 'exiftool_opened', + EXIT: 'exiftool_exit' +}; + +var ExiftoolProcess = function (_EventEmitter) { + _inherits(ExiftoolProcess, _EventEmitter); + + /** + * Create an instance of ExiftoolProcess class. + * @param {string} [bin="exiftool"] path to executable + */ + function ExiftoolProcess(bin) { + _classCallCheck(this, ExiftoolProcess); + + var _this = _possibleConstructorReturn(this, (ExiftoolProcess.__proto__ || Object.getPrototypeOf(ExiftoolProcess)).call(this)); + + _this._bin = lib.isString(bin) ? bin : EXIFTOOL_PATH; + _this._process = undefined; + _this._open = false; + return _this; + } + + /** + * Close the exiftool process by passing -stay_open false. + * @returns {Promise} a promise to stop the process. + */ + + + _createClass(ExiftoolProcess, [{ + key: 'close', + value: function close() { + if (!this._open) { + return Promise.reject(new Error('Exiftool process is not open')); + } + return lib.close(this._process); + } + }, { + key: '_assignEncoding', + value: function _assignEncoding(encoding) { + var _encoding = void 0; + if (encoding === null) { + _encoding = undefined; + } else if (lib.isString(encoding)) { + _encoding = encoding; + } else { + _encoding = 'utf8'; + } + this._encoding = _encoding; + } + /** + * Spawn exiftool process with -stay_open True -@ - arguments. + * Options can be passed as the first argument instead of encoding. + * @param {string} [encoding="utf8"] Encoding with which to read from and + * write to streams. pass null to not use encoding, utf8 otherwise + * @param {object} [options] options to pass to the spawn method + * @returns {Promise.} A promise to spawn exiftool in stay_open + * mode, resolved with pid. + */ + + }, { + key: 'open', + value: function () { + var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(encoding, options) { + var _encoding, _options, exiftoolProcess; + + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + _encoding = encoding; + _options = options; + // if encoding is not a string and options are not given, treat it as options + + if (options === undefined && typeof encoding !== 'string') { + _encoding = undefined; + _options = encoding; + } + this._assignEncoding(_encoding); + + if (!this._open) { + _context.next = 6; + break; + } + + throw new Error('Exiftool process is already open'); + + case 6: + _context.next = 8; + return lib.spawn(this._bin, _options); + + case 8: + exiftoolProcess = _context.sent; + + //console.log(`Started exiftool process %s`, process.pid); + this.emit(events.OPEN, exiftoolProcess.pid); + this._process = exiftoolProcess; + + this._process.on('exit', this._exitListener.bind(this)); + + if (lib.isReadable(this._process.stdout)) { + _context.next = 15; + break; + } + + lib.killProcess(this._process); + throw new Error('Process was not spawned with a readable stdout, check stdio options.'); + + case 15: + if (lib.isWritable(this._process.stdin)) { + _context.next = 18; + break; + } + + lib.killProcess(this._process); + throw new Error('Process was not spawned with a writable stdin, check stdio options.'); + + case 18: + + // if process was spawned, stderr is readable (see lib/spawn) + + this._process.stdout.setEncoding(this._encoding); + this._process.stderr.setEncoding(this._encoding); + + // resolve-write streams + this._stdoutResolveWs = beginReady.setupResolveWriteStreamPipe(this._process.stdout); + this._stderrResolveWs = beginReady.setupResolveWriteStreamPipe(this._process.stderr); + + // handle errors so that Node does not crash + this._stdoutResolveWs.on('error', console.error); // eslint-disable-line no-console + this._stderrResolveWs.on('error', console.error); // eslint-disable-line no-console + + // debug + // exiftoolProcess.stdout.pipe(process.stdout) + // exiftoolProcess.stderr.pipe(process.stderr) + + this._open = true; + + return _context.abrupt('return', exiftoolProcess.pid); + + case 26: + case 'end': + return _context.stop(); + } + } + }, _callee, this); + })); + + function open(_x, _x2) { + return _ref.apply(this, arguments); + } + + return open; + }() + }, { + key: '_exitListener', + value: function _exitListener() { + // console.log('exiftool process exit') + this.emit(events.EXIT); + this._open = false; // try to re-spawn? + } + + /** + * Checks if process is opens. + * @returns {boolean} true if open and false otherwise. + */ + + }, { + key: '_executeCommand', + value: function () { + var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(command, args, argsNoSplit, debug) { + var proc; + return regeneratorRuntime.wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + if (this._open) { + _context2.next = 2; + break; + } + + throw new Error('exiftool is not open'); + + case 2: + if (!(this._process.signalCode === 'SIGTERM')) { + _context2.next = 4; + break; + } + + throw new Error('Could not connect to the exiftool process'); + + case 4: + proc = debug === true ? process : this._process; + return _context2.abrupt('return', lib.executeCommand(proc, this._stdoutResolveWs, this._stderrResolveWs, command, args, argsNoSplit, this._encoding)); + + case 6: + case 'end': + return _context2.stop(); + } + } + }, _callee2, this); + })); + + function _executeCommand(_x3, _x4, _x5, _x6) { + return _ref2.apply(this, arguments); + } + + return _executeCommand; + }() + + /** + * Read metadata of a file or directory. + * @param {string|Readable} file path to the file or directory, or a + * readable stream + * @param {string[]} args any additional arguments, e.g., ['Orientation#'] + * to report Orientation only, or ['-FileSize'] to exclude FileSize + * @returns {Promise.<{data: object[]|null, error: string|null}>} a promise + * resolved with parsed stdout and stderr. + */ + + }, { + key: 'readMetadata', + value: function readMetadata(file, args) { + if (lib.isReadable(file)) { + return executeWithRs(file, args, this._executeCommand.bind(this)); + } + return this._executeCommand(file, args); + } + + /** + * Write metadata to a file or directory. + * @param {string} file path to the file or directory + * @param {object} data data to write, with keys as tags + * @param {string[]} args additional arguments, e.g., ['overwrite_original'] + * @param {boolean} debug whether to print to stdout + * @returns {Promise.<{{data, error}}>} A promise to write metadata, + * resolved with data from stdout and stderr. + */ + + }, { + key: 'writeMetadata', + value: function () { + var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(file, data, args, debug) { + var writeArgs; + return regeneratorRuntime.wrap(function _callee3$(_context3) { + while (1) { + switch (_context3.prev = _context3.next) { + case 0: + if (lib.isString(file)) { + _context3.next = 2; + break; + } + + throw new Error('File must be a string'); + + case 2: + if (lib.checkDataObject(data)) { + _context3.next = 4; + break; + } + + throw new Error('Data argument is not an object'); + + case 4: + writeArgs = lib.mapDataToTagArray(data); + return _context3.abrupt('return', this._executeCommand(file, args, writeArgs, debug)); + + case 6: + case 'end': + return _context3.stop(); + } + } + }, _callee3, this); + })); + + function writeMetadata(_x7, _x8, _x9, _x10) { + return _ref3.apply(this, arguments); + } + + return writeMetadata; + }() + }, { + key: 'isOpen', + get: function get() { + return this._open; + } + }]); + + return ExiftoolProcess; +}(EventEmitter); + +module.exports = { + ExiftoolProcess: ExiftoolProcess, + EXIFTOOL_PATH: EXIFTOOL_PATH, + events: events +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/index.js"],"names":["EventEmitter","require","lib","beginReady","executeWithRs","EXIFTOOL_PATH","events","OPEN","EXIT","ExiftoolProcess","bin","_bin","isString","_process","undefined","_open","Promise","reject","Error","close","encoding","_encoding","options","_options","_assignEncoding","spawn","exiftoolProcess","emit","pid","on","_exitListener","bind","isReadable","stdout","killProcess","isWritable","stdin","setEncoding","stderr","_stdoutResolveWs","setupResolveWriteStreamPipe","_stderrResolveWs","console","error","command","args","argsNoSplit","debug","signalCode","proc","process","executeCommand","file","_executeCommand","data","checkDataObject","writeArgs","mapDataToTagArray","module","exports"],"mappings":";;;;;;;;;;;;;;AAAA,IAAMA,eAAeC,QAAQ,QAAR,CAArB;AACA,IAAMC,MAAMD,QAAQ,OAAR,CAAZ;AACA,IAAME,aAAaF,QAAQ,eAAR,CAAnB;AACA,IAAMG,gBAAgBH,QAAQ,mBAAR,CAAtB;;AAEA,IAAMI,gBAAgB,UAAtB;;AAEA,IAAMC,SAAS;AACXC,UAAM,iBADK;AAEXC,UAAM;AAFK,CAAf;;IAKMC,e;;;AACF;;;;AAIA,6BAAYC,GAAZ,EAAiB;AAAA;;AAAA;;AAEb,cAAKC,IAAL,GAAYT,IAAIU,QAAJ,CAAaF,GAAb,IAAoBA,GAApB,GAA0BL,aAAtC;AACA,cAAKQ,QAAL,GAAgBC,SAAhB;AACA,cAAKC,KAAL,GAAa,KAAb;AAJa;AAKhB;;AAED;;;;;;;;gCAIQ;AACJ,gBAAI,CAAC,KAAKA,KAAV,EAAiB;AACb,uBAAOC,QAAQC,MAAR,CAAe,IAAIC,KAAJ,CAAU,8BAAV,CAAf,CAAP;AACH;AACD,mBAAOhB,IAAIiB,KAAJ,CAAU,KAAKN,QAAf,CAAP;AACH;;;wCAEeO,Q,EAAU;AACtB,gBAAIC,kBAAJ;AACA,gBAAID,aAAa,IAAjB,EAAuB;AACnBC,4BAAYP,SAAZ;AACH,aAFD,MAEO,IAAIZ,IAAIU,QAAJ,CAAaQ,QAAb,CAAJ,EAA4B;AAC/BC,4BAAYD,QAAZ;AACH,aAFM,MAEA;AACHC,4BAAY,MAAZ;AACH;AACD,iBAAKA,SAAL,GAAiBA,SAAjB;AACH;AACD;;;;;;;;;;;;;gGASWD,Q,EAAUE,O;;;;;;;AACbD,yC,GAAYD,Q;AACZG,wC,GAAWD,O;AACf;;AACA,oCAAIA,YAAYR,SAAZ,IAAyB,OAAOM,QAAP,KAAoB,QAAjD,EAA2D;AACvDC,gDAAYP,SAAZ;AACAS,+CAAWH,QAAX;AACH;AACD,qCAAKI,eAAL,CAAqBH,SAArB;;qCACI,KAAKN,K;;;;;sCACC,IAAIG,KAAJ,CAAU,kCAAV,C;;;;uCAEoBhB,IAAIuB,KAAJ,CAAU,KAAKd,IAAf,EAAqBY,QAArB,C;;;AAAxBG,+C;;AACN;AACA,qCAAKC,IAAL,CAAUrB,OAAOC,IAAjB,EAAuBmB,gBAAgBE,GAAvC;AACA,qCAAKf,QAAL,GAAgBa,eAAhB;;AAEA,qCAAKb,QAAL,CAAcgB,EAAd,CAAiB,MAAjB,EAAyB,KAAKC,aAAL,CAAmBC,IAAnB,CAAwB,IAAxB,CAAzB;;oCACK7B,IAAI8B,UAAJ,CAAe,KAAKnB,QAAL,CAAcoB,MAA7B,C;;;;;AACD/B,oCAAIgC,WAAJ,CAAgB,KAAKrB,QAArB;sCACM,IAAIK,KAAJ,CAAU,sEAAV,C;;;oCAELhB,IAAIiC,UAAJ,CAAe,KAAKtB,QAAL,CAAcuB,KAA7B,C;;;;;AACDlC,oCAAIgC,WAAJ,CAAgB,KAAKrB,QAArB;sCACM,IAAIK,KAAJ,CAAU,qEAAV,C;;;;AAGV;;AAEA,qCAAKL,QAAL,CAAcoB,MAAd,CAAqBI,WAArB,CAAiC,KAAKhB,SAAtC;AACA,qCAAKR,QAAL,CAAcyB,MAAd,CAAqBD,WAArB,CAAiC,KAAKhB,SAAtC;;AAEA;AACA,qCAAKkB,gBAAL,GAAwBpC,WAAWqC,2BAAX,CAAuC,KAAK3B,QAAL,CAAcoB,MAArD,CAAxB;AACA,qCAAKQ,gBAAL,GAAwBtC,WAAWqC,2BAAX,CAAuC,KAAK3B,QAAL,CAAcyB,MAArD,CAAxB;;AAEA;AACA,qCAAKC,gBAAL,CAAsBV,EAAtB,CAAyB,OAAzB,EAAkCa,QAAQC,KAA1C,E,CAAiD;AACjD,qCAAKF,gBAAL,CAAsBZ,EAAtB,CAAyB,OAAzB,EAAkCa,QAAQC,KAA1C,E,CAAiD;;AAEjD;AACA;AACA;;AAEA,qCAAK5B,KAAL,GAAa,IAAb;;iEAEOW,gBAAgBE,G;;;;;;;;;;;;;;;;;;wCAGX;AACZ;AACA,iBAAKD,IAAL,CAAUrB,OAAOE,IAAjB;AACA,iBAAKO,KAAL,GAAa,KAAb,CAHY,CAGO;AACtB;;AAED;;;;;;;;kGAQsB6B,O,EAASC,I,EAAMC,W,EAAaC,K;;;;;;oCAEzC,KAAKhC,K;;;;;sCACA,IAAIG,KAAJ,CAAU,sBAAV,C;;;sCAEN,KAAKL,QAAL,CAAcmC,UAAd,KAA6B,S;;;;;sCACvB,IAAI9B,KAAJ,CAAU,2CAAV,C;;;AAGJ+B,oC,GAAOF,UAAU,IAAV,GAAiBG,OAAjB,GAA2B,KAAKrC,Q;kEACtCX,IAAIiD,cAAJ,CAAmBF,IAAnB,EAAyB,KAAKV,gBAA9B,EACH,KAAKE,gBADF,EACoBG,OADpB,EAC6BC,IAD7B,EACmCC,WADnC,EACgD,KAAKzB,SADrD,C;;;;;;;;;;;;;;;;;AAIX;;;;;;;;;;;;qCASa+B,I,EAAMP,I,EAAM;AACrB,gBAAI3C,IAAI8B,UAAJ,CAAeoB,IAAf,CAAJ,EAA0B;AACtB,uBAAOhD,cAAcgD,IAAd,EAAoBP,IAApB,EAA0B,KAAKQ,eAAL,CAAqBtB,IAArB,CAA0B,IAA1B,CAA1B,CAAP;AACH;AACD,mBAAO,KAAKsB,eAAL,CAAqBD,IAArB,EAA2BP,IAA3B,CAAP;AACH;;AAED;;;;;;;;;;;;;kGASoBO,I,EAAME,I,EAAMT,I,EAAME,K;;;;;;oCAC7B7C,IAAIU,QAAJ,CAAawC,IAAb,C;;;;;sCACK,IAAIlC,KAAJ,CAAU,uBAAV,C;;;oCAELhB,IAAIqD,eAAJ,CAAoBD,IAApB,C;;;;;sCACK,IAAIpC,KAAJ,CAAU,gCAAV,C;;;AAGJsC,yC,GAAYtD,IAAIuD,iBAAJ,CAAsBH,IAAtB,C;kEACX,KAAKD,eAAL,CAAqBD,IAArB,EAA2BP,IAA3B,EAAiCW,SAAjC,EAA4CT,KAA5C,C;;;;;;;;;;;;;;;;;;4BApDE;AACT,mBAAO,KAAKhC,KAAZ;AACH;;;;EAxGyBf,Y;;AA8J9B0D,OAAOC,OAAP,GAAiB;AACblD,oCADa;AAEbJ,gCAFa;AAGbC;AAHa,CAAjB","file":"index.js","sourcesContent":["const EventEmitter = require('events')\nconst lib = require('./lib')\nconst beginReady = require('./begin-ready')\nconst executeWithRs = require('./execute-with-rs')\n\nconst EXIFTOOL_PATH = 'exiftool'\n\nconst events = {\n    OPEN: 'exiftool_opened',\n    EXIT: 'exiftool_exit',\n}\n\nclass ExiftoolProcess extends EventEmitter {\n    /**\n     * Create an instance of ExiftoolProcess class.\n     * @param {string} [bin=\"exiftool\"] path to executable\n     */\n    constructor(bin) {\n        super()\n        this._bin = lib.isString(bin) ? bin : EXIFTOOL_PATH\n        this._process = undefined\n        this._open = false\n    }\n\n    /**\n     * Close the exiftool process by passing -stay_open false.\n     * @returns {Promise} a promise to stop the process.\n     */\n    close() {\n        if (!this._open) {\n            return Promise.reject(new Error('Exiftool process is not open'))\n        }\n        return lib.close(this._process)\n    }\n\n    _assignEncoding(encoding) {\n        let _encoding\n        if (encoding === null) {\n            _encoding = undefined\n        } else if (lib.isString(encoding)) {\n            _encoding = encoding\n        } else {\n            _encoding = 'utf8'\n        }\n        this._encoding = _encoding\n    }\n    /**\n     * Spawn exiftool process with -stay_open True -@ - arguments.\n     * Options can be passed as the first argument instead of encoding.\n     * @param {string} [encoding=\"utf8\"] Encoding with which to read from and\n     * write to streams. pass null to not use encoding, utf8 otherwise\n     * @param {object} [options] options to pass to the spawn method\n     * @returns {Promise.<number>} A promise to spawn exiftool in stay_open\n     * mode, resolved with pid.\n     */\n    async open(encoding, options) {\n        let _encoding = encoding\n        let _options = options\n        // if encoding is not a string and options are not given, treat it as options\n        if (options === undefined && typeof encoding !== 'string') {\n            _encoding = undefined\n            _options = encoding\n        }\n        this._assignEncoding(_encoding)\n        if (this._open) {\n            throw new Error('Exiftool process is already open')\n        }\n        const exiftoolProcess = await lib.spawn(this._bin, _options)\n        //console.log(`Started exiftool process %s`, process.pid);\n        this.emit(events.OPEN, exiftoolProcess.pid)\n        this._process = exiftoolProcess\n\n        this._process.on('exit', this._exitListener.bind(this))\n        if (!lib.isReadable(this._process.stdout)) {\n            lib.killProcess(this._process)\n            throw new Error('Process was not spawned with a readable stdout, check stdio options.')\n        }\n        if (!lib.isWritable(this._process.stdin)) {\n            lib.killProcess(this._process)\n            throw new Error('Process was not spawned with a writable stdin, check stdio options.')\n        }\n\n        // if process was spawned, stderr is readable (see lib/spawn)\n\n        this._process.stdout.setEncoding(this._encoding)\n        this._process.stderr.setEncoding(this._encoding)\n\n        // resolve-write streams\n        this._stdoutResolveWs = beginReady.setupResolveWriteStreamPipe(this._process.stdout)\n        this._stderrResolveWs = beginReady.setupResolveWriteStreamPipe(this._process.stderr)\n\n        // handle errors so that Node does not crash\n        this._stdoutResolveWs.on('error', console.error) // eslint-disable-line no-console\n        this._stderrResolveWs.on('error', console.error) // eslint-disable-line no-console\n\n        // debug\n        // exiftoolProcess.stdout.pipe(process.stdout)\n        // exiftoolProcess.stderr.pipe(process.stderr)\n\n        this._open = true\n\n        return exiftoolProcess.pid\n    }\n\n    _exitListener() {\n        // console.log('exiftool process exit')\n        this.emit(events.EXIT)\n        this._open = false // try to re-spawn?\n    }\n\n    /**\n     * Checks if process is opens.\n     * @returns {boolean} true if open and false otherwise.\n     */\n    get isOpen() {\n        return this._open\n    }\n\n    async _executeCommand(command, args, argsNoSplit, debug) {\n        //test this!\n        if (!this._open) {\n            throw new Error('exiftool is not open')\n        }\n        if (this._process.signalCode === 'SIGTERM') {\n            throw new Error('Could not connect to the exiftool process')\n        }\n\n        const proc = debug === true ? process : this._process\n        return lib.executeCommand(proc, this._stdoutResolveWs,\n            this._stderrResolveWs, command, args, argsNoSplit, this._encoding)\n    }\n\n    /**\n     * Read metadata of a file or directory.\n     * @param {string|Readable} file path to the file or directory, or a\n     * readable stream\n     * @param {string[]} args any additional arguments, e.g., ['Orientation#']\n     * to report Orientation only, or ['-FileSize'] to exclude FileSize\n     * @returns {Promise.<{data: object[]|null, error: string|null}>} a promise\n     * resolved with parsed stdout and stderr.\n     */\n    readMetadata(file, args) {\n        if (lib.isReadable(file)) {\n            return executeWithRs(file, args, this._executeCommand.bind(this))\n        }\n        return this._executeCommand(file, args)\n    }\n\n    /**\n     * Write metadata to a file or directory.\n     * @param {string} file path to the file or directory\n     * @param {object} data data to write, with keys as tags\n     * @param {string[]} args additional arguments, e.g., ['overwrite_original']\n     * @param {boolean} debug whether to print to stdout\n     * @returns {Promise.<{{data, error}}>} A promise to write metadata,\n     * resolved with data from stdout and stderr.\n     */\n    async writeMetadata(file, data, args, debug) {\n        if (!lib.isString(file)) {\n            throw new Error('File must be a string')\n        }\n        if (!lib.checkDataObject(data)) {\n            throw new Error('Data argument is not an object')\n        }\n\n        const writeArgs = lib.mapDataToTagArray(data)\n        return this._executeCommand(file, args, writeArgs, debug)\n    }\n}\n\nmodule.exports = {\n    ExiftoolProcess,\n    EXIFTOOL_PATH,\n    events,\n}\n"]} \ No newline at end of file diff --git a/dist/src/lib.js b/dist/src/lib.js new file mode 100644 index 0000000..ffcd066 --- /dev/null +++ b/dist/src/lib.js @@ -0,0 +1,226 @@ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +require('source-map-support/register'); + +var cp = require('child_process'); + +var _require = require('os'), + EOL = _require.EOL; + +var isStream = require('is-stream'); +var erotic = require('erotic'); + +function writeStdIn(proc, data, encoding) { + // console.log('write stdin', data) + proc.stdin.write(data, encoding); + proc.stdin.write(EOL, encoding); +} + +function close(proc) { + var er = erotic(); + var errHandler = void 0; + return new Promise(function (resolve, reject) { + errHandler = function errHandler(_ref) { + var message = _ref.message; + + var err = er(message); + reject(err); + }; + proc.once('close', resolve); + proc.stdin.once('error', errHandler); + writeStdIn(proc, '-stay_open'); + writeStdIn(proc, 'false'); + }).then(function () { + proc.stdin.removeListener('error', errHandler); + }); +} + +function isString(s) { + return (typeof s === 'undefined' ? 'undefined' : _typeof(s)).toLowerCase() === 'string'; +} + +function isObject(o) { + return (typeof o === 'undefined' ? 'undefined' : _typeof(o)).toLowerCase() === 'object' && o !== null; +} + +/** + * Get arguments. Split by new line to write to exiftool + */ +function getArgs(args, noSplit) { + if (!(Array.isArray(args) && args.length)) { + return []; + } + return args.filter(isString).map(function (arg) { + return '-' + arg; + }).reduce(function (acc, arg) { + return [].concat(acc, noSplit ? [arg] : arg.split(/\s+/)); + }, []); +} + +/** + * Write command data to the exiftool's stdin. + * @param {ChildProcess} process - exiftool process executed with -stay_open True -@ - + * @param {string} command - which command to execute + * @param {string} commandNumber - text which will be echoed before and after results + * @param {string[]} args - any additional arguments + * @param {string[]} noSplitArgs - arguments which should not be broken up like args + * @param {string} encoding - which encoding to write in. default no encoding + */ +function execute(proc, command, commandNumber, args, noSplitArgs, encoding) { + var extendedArgs = getArgs(args); + var extendedArgsNoSplit = getArgs(noSplitArgs, true); + + command = command !== undefined ? command : ''; + + var allArgs = [].concat(extendedArgsNoSplit, extendedArgs, ['-json', '-s'], [command, '-echo1', '{begin' + commandNumber + '}', '-echo2', '{begin' + commandNumber + '}', '-echo4', '{ready' + commandNumber + '}', '-execute' + commandNumber]); + if (process.env.DEBUG) { + // eslint-disable-next-line no-console + console.log(JSON.stringify(allArgs, null, 2)); + } + allArgs.forEach(function (arg) { + return writeStdIn(proc, arg, encoding); + }); +} + +var currentCommand = 0; +function genCommandNumber() { + return String(++currentCommand); +} + +function executeCommand(proc, stdoutRws, stderrRws, command, args, noSplitArgs, encoding) { + var commandNumber = genCommandNumber(); + + if (proc === process) { + // debugging + execute(proc, command, commandNumber, args, noSplitArgs, encoding); + return Promise.resolve({ data: 'debug', error: null }); + } + + var dataFinishHandler = void 0; + var errFinishHandler = void 0; + var dataErr = void 0; + var errErr = void 0; + + var dataPromise = new Promise(function (resolve, reject) { + dataFinishHandler = function dataFinishHandler() { + reject(new Error('stdout stream finished before operation was complete')); + }; + stdoutRws.once('finish', dataFinishHandler); + stdoutRws.addToResolveMap(commandNumber, resolve); + }).catch(function (error) { + dataErr = error; + }); + var errPromise = new Promise(function (resolve, reject) { + errFinishHandler = function errFinishHandler() { + reject(new Error('stderr stream finished before operation was complete')); + }; + stderrRws.once('finish', errFinishHandler); + stderrRws.addToResolveMap(commandNumber, resolve); + }).catch(function (error) { + errErr = error; + }); + + execute(proc, command, commandNumber, args, noSplitArgs, encoding); + + return Promise.all([dataPromise, errPromise]).then(function (res) { + stderrRws.removeListener('finish', errFinishHandler); + stdoutRws.removeListener('finish', dataFinishHandler); + if (dataErr && !errErr) { + throw dataErr; + } else if (errErr && !dataErr) { + throw errErr; + } else if (dataErr && errErr) { + throw new Error('stdout and stderr finished before operation was complete'); + } + return { + data: res[0] ? JSON.parse(res[0]) : null, + error: res[1] || null + }; + }); +} + +function isReadable(stream) { + return isStream.readable(stream); +} +function isWritable(stream) { + return isStream.writable(stream); +} + +/** + * Spawn exiftool. + * @param {string} bin Path to the binary + * @param {object} [options] options to pass to child_process.spawn method + * @returns {Promise.} A promise resolved with the process pointer, or rejected on error. + */ +function spawn(bin, options) { + var echoString = Date.now().toString(); + var proc = cp.spawn(bin, ['-echo2', echoString, '-stay_open', 'True', '-@', '-'], options); + if (!isReadable(proc.stderr)) { + killProcess(proc); + return Promise.reject(new Error('Process was not spawned with a readable stderr, check stdio options.')); + } + + return new Promise(function (resolve, reject) { + var echoHandler = function echoHandler(data) { + var d = data.toString().trim(); + // listening for echo2 in stderr (echo and echo1 won't work) + if (d === echoString) { + resolve(proc); + } else { + reject(new Error('Unexpected string on start: ' + d)); + } + }; + proc.stderr.once('data', echoHandler); + proc.once('error', reject); + }); +} + +function checkDataObject(data) { + return data === Object(data) && !Array.isArray(data); +} + +function mapDataToTagArray(data, array) { + var res = Array.isArray(array) ? array : []; + Object.keys(data).forEach(function (tag) { + var value = data[tag]; + if (Array.isArray(value)) { + value.forEach(function (v) { + var arg = tag + '=' + v; + res.push(arg); + }); + } else { + res.push(tag + '=' + value); + } + }); + return res; +} + +/** + * Use process.kill on POSIX or terminate process with taskkill on Windows. + * @param {ChildProcess} proc Process to terminate + */ +function killProcess(proc) { + if (process.platform === 'win32') { + cp.exec('taskkill /t /F /PID ' + proc.pid); + } else { + proc.kill(); + } +} + +module.exports = { + spawn: spawn, + close: close, + executeCommand: executeCommand, + checkDataObject: checkDataObject, + mapDataToTagArray: mapDataToTagArray, + getArgs: getArgs, + execute: execute, + isString: isString, + isObject: isObject, + isReadable: isReadable, + isWritable: isWritable, + killProcess: killProcess +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/lib.js"],"names":["cp","require","EOL","isStream","erotic","writeStdIn","proc","data","encoding","stdin","write","close","er","errHandler","Promise","resolve","reject","message","err","once","then","removeListener","isString","s","toLowerCase","isObject","o","getArgs","args","noSplit","Array","isArray","length","filter","map","arg","reduce","acc","concat","split","execute","command","commandNumber","noSplitArgs","extendedArgs","extendedArgsNoSplit","undefined","allArgs","process","env","DEBUG","console","log","JSON","stringify","forEach","currentCommand","genCommandNumber","String","executeCommand","stdoutRws","stderrRws","error","dataFinishHandler","errFinishHandler","dataErr","errErr","dataPromise","Error","addToResolveMap","catch","errPromise","all","res","parse","isReadable","stream","readable","isWritable","writable","spawn","bin","options","echoString","Date","now","toString","stderr","killProcess","echoHandler","d","trim","checkDataObject","Object","mapDataToTagArray","array","keys","value","tag","v","push","platform","exec","pid","kill","module","exports"],"mappings":"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","file":"lib.js","sourcesContent":["const cp = require('child_process')\nconst { EOL } = require('os')\nconst isStream = require('is-stream')\nconst erotic = require('erotic')\n\nfunction writeStdIn(proc, data, encoding) {\n    // console.log('write stdin', data)\n    proc.stdin.write(data, encoding)\n    proc.stdin.write(EOL, encoding)\n}\n\nfunction close(proc) {\n    const er = erotic()\n    let errHandler\n    return new Promise((resolve, reject) => {\n        errHandler = ({ message }) => {\n            const err = er(message)\n            reject(err)\n        }\n        proc.once('close', resolve)\n        proc.stdin.once('error', errHandler)\n        writeStdIn(proc, '-stay_open')\n        writeStdIn(proc, 'false')\n    }).then(() => {\n        proc.stdin.removeListener('error', errHandler)\n    })\n}\n\nfunction isString(s) {\n    return (typeof s).toLowerCase() === 'string'\n}\n\nfunction isObject(o) {\n    return (typeof o).toLowerCase() === 'object' && o !== null\n}\n\n/**\n * Get arguments. Split by new line to write to exiftool\n */\nfunction getArgs(args, noSplit) {\n    if(!(Array.isArray(args) && args.length)) {\n        return []\n    }\n    return args\n        .filter(isString)\n        .map(arg => `-${arg}`)\n        .reduce((acc, arg) =>\n            [].concat(acc, noSplit ? [arg] : arg.split(/\\s+/))\n            , [])\n}\n\n/**\n * Write command data to the exiftool's stdin.\n * @param {ChildProcess} process - exiftool process executed with -stay_open True -@ -\n * @param {string} command - which command to execute\n * @param {string} commandNumber - text which will be echoed before and after results\n * @param {string[]} args - any additional arguments\n * @param {string[]} noSplitArgs - arguments which should not be broken up like args\n * @param {string} encoding - which encoding to write in. default no encoding\n */\nfunction execute(proc, command, commandNumber, args, noSplitArgs, encoding) {\n    const extendedArgs = getArgs(args)\n    const extendedArgsNoSplit = getArgs(noSplitArgs, true)\n\n    command = command !== undefined ? command : ''\n\n    const allArgs = [].concat(\n        extendedArgsNoSplit,\n        extendedArgs,\n        ['-json', '-s'],\n        [\n            command,\n            '-echo1',\n            `{begin${commandNumber}}`,\n            '-echo2',\n            `{begin${commandNumber}}`,\n            '-echo4',\n            `{ready${commandNumber}}`,\n            `-execute${commandNumber}`,\n        ]\n    )\n    if (process.env.DEBUG) {\n        // eslint-disable-next-line no-console\n        console.log(JSON.stringify(allArgs, null, 2))\n    }\n    allArgs.forEach(arg => writeStdIn(proc, arg, encoding))\n}\n\nlet currentCommand = 0\nfunction genCommandNumber() {\n    return String(++currentCommand)\n}\n\nfunction executeCommand(proc, stdoutRws, stderrRws, command, args, noSplitArgs, encoding) {\n    const commandNumber = genCommandNumber()\n\n    if (proc === process) { // debugging\n        execute(proc, command, commandNumber, args, noSplitArgs, encoding)\n        return Promise.resolve({ data: 'debug', error: null })\n    }\n\n    let dataFinishHandler\n    let errFinishHandler\n    let dataErr\n    let errErr\n\n    const dataPromise = new Promise((resolve, reject) => {\n        dataFinishHandler = () => {\n            reject(new Error('stdout stream finished before operation was complete'))\n        }\n        stdoutRws.once('finish', dataFinishHandler)\n        stdoutRws.addToResolveMap(commandNumber, resolve)\n    }).catch(error => { dataErr = error })\n    const errPromise = new Promise((resolve, reject) => {\n        errFinishHandler = () => {\n            reject(new Error('stderr stream finished before operation was complete'))\n        }\n        stderrRws.once('finish', errFinishHandler)\n        stderrRws.addToResolveMap(commandNumber, resolve)\n    }).catch(error => { errErr = error })\n\n    execute(proc, command, commandNumber, args, noSplitArgs, encoding)\n\n    return Promise.all([\n        dataPromise,\n        errPromise,\n    ])\n        .then((res) => {\n            stderrRws.removeListener('finish', errFinishHandler)\n            stdoutRws.removeListener('finish', dataFinishHandler)\n            if (dataErr && !errErr) {\n                throw dataErr\n            } else if (errErr && !dataErr) {\n                throw errErr\n            } else if (dataErr && errErr) {\n                throw new Error('stdout and stderr finished before operation was complete')\n            }\n            return {\n                data: res[0] ? JSON.parse(res[0]) : null,\n                error: res[1] || null,\n            }\n        })\n}\n\nfunction isReadable(stream) {\n    return isStream.readable(stream)\n}\nfunction isWritable(stream) {\n    return isStream.writable(stream)\n}\n\n/**\n * Spawn exiftool.\n * @param {string} bin Path to the binary\n * @param {object} [options] options to pass to child_process.spawn method\n * @returns {Promise.<ChildProcess>} A promise resolved with the process pointer, or rejected on error.\n */\nfunction spawn(bin, options) {\n    const echoString = Date.now().toString()\n    const proc = cp.spawn(bin, ['-echo2', echoString, '-stay_open', 'True', '-@', '-'], options)\n    if (!isReadable(proc.stderr)) {\n        killProcess(proc)\n        return Promise.reject(new Error('Process was not spawned with a readable stderr, check stdio options.'))\n    }\n\n    return new Promise((resolve, reject) => {\n        const echoHandler = (data) => {\n            const d = data.toString().trim()\n            // listening for echo2 in stderr (echo and echo1 won't work)\n            if (d === echoString) {\n                resolve(proc)\n            } else {\n                reject(new Error(`Unexpected string on start: ${d}`))\n            }\n        }\n        proc.stderr.once('data', echoHandler)\n        proc.once('error', reject)\n    })\n}\n\nfunction checkDataObject(data) {\n    return data === Object(data) && !Array.isArray(data)\n}\n\nfunction mapDataToTagArray(data, array) {\n    const res = Array.isArray(array) ? array : []\n    Object\n        .keys(data)\n        .forEach(tag => {\n            const value = data[tag]\n            if (Array.isArray(value)) {\n                value.forEach((v) => {\n                    const arg = `${tag}=${v}`\n                    res.push(arg)\n                })\n            } else {\n                res.push(`${tag}=${value}`)\n            }\n        })\n    return res\n}\n\n/**\n * Use process.kill on POSIX or terminate process with taskkill on Windows.\n * @param {ChildProcess} proc Process to terminate\n */\nfunction killProcess(proc) {\n    if (process.platform === 'win32') {\n        cp.exec(`taskkill /t /F /PID ${proc.pid}`)\n    } else {\n        proc.kill()\n    }\n}\n\nmodule.exports = {\n    spawn,\n    close,\n    executeCommand,\n    checkDataObject,\n    mapDataToTagArray,\n    getArgs,\n    execute,\n    isString,\n    isObject,\n    isReadable,\n    isWritable,\n    killProcess,\n}\n"]} \ No newline at end of file diff --git a/dist/test/context/detached.js b/dist/test/context/detached.js new file mode 100644 index 0000000..6ffb4f0 --- /dev/null +++ b/dist/test/context/detached.js @@ -0,0 +1,114 @@ +'use strict'; + +require('source-map-support/register'); + +var cp = require('child_process'); +var makepromise = require('makepromise'); +var debuglog = require('util').debuglog('detached'); +var path = require('path'); + +var FORK_PATH = path.join(__dirname, '../fixtures/detached'); + +var isWindows = process.platform === 'win32'; + +var createFork = function createFork(modulePath, detached, env) { + return cp.spawn(process.argv[0], [modulePath], { + detached: detached, + // not doing this will not allow debugging, as fork will try to connect + // to the same debug port as parent + execArgv: [], + env: Object.assign({}, process.env, env), + stdio: ['pipe', 'pipe', 'pipe', 'ipc'] + }); +}; + +function getGrep(include, exclude) { + var grep = include.join('\\|'); + var vgrep = [].concat(exclude, 'grep').join('\\|'); + var com = ['ps xao pid,ppid,pgid,stat,sess,tt,tty,command']; + if (grep) com.push('grep \'' + grep + '\''); + com.push('grep -v \'' + vgrep + '\''); + var s = com.join(' | '); + return s; +} + +function getWmic(include) { + var procs = include.map(function (p) { + return 'caption=\'' + p + '\''; + }).join(' or '); + return 'wmic process where "' + procs + '" get caption,processid,parentprocessid'; +} + +function ps(comment) { + var psInclude = ['node', 'perl', 'npm']; + var psExclude = ['Visual']; + var wmicInclude = ['node.exe', 'exiftool.exe', 'conhost.exe']; + var s = isWindows ? getWmic(wmicInclude) : getGrep(psInclude, psExclude); + return makepromise(cp.exec, [s]).then(function (r) { + debuglog(comment); + debuglog('======\n' + r); + debuglog('======'); + }); +} + +function killFork(proc, withGroup) { + return new Promise(function (resolve, reject) { + proc.once('exit', function () { + debuglog('killed %s', proc.pid); + resolve(); + }); + try { + var p = withGroup ? -proc.pid : proc.pid; + debuglog('going to kill %s', p); + process.kill(p); + } catch (err) { + debuglog(err.message); + reject(err); + } + }); +} + +/** + * This context will allow to create and destroy Node fork. + */ +var context = function DetachedContext() { + var _this = this; + + this.fork = null; + this.epPid = null; + + this.forkNode = function (exiftoolDetached) { + return ps('before starting fork').then(function () { + var env = exiftoolDetached ? { EXIFTOOL_DETACHED: true } : {}; + _this.fork = createFork(FORK_PATH, true, env); + debuglog('fork pid: %s', _this.fork.pid); + return new Promise(function (resolve) { + _this.fork.on('message', resolve); + }); + }).then(function (res) { + _this.epPid = res; + debuglog('exiftool pid: %s', _this.epPid); + _this.fork.on('disconnect', function () { + debuglog('fork disconnected'); + }); + _this.fork.on('exit', function () { + debuglog('fork exited'); + }); + return ps('after starting fork'); + }).then(function () { + return { epPid: _this.epPid, forkPid: _this.fork.pid }; + }); + }; + this.killFork = function (withGroup) { + if (!_this.fork) { + return Promise.reject(new Error('fork has not started')); + } + return killFork(_this.fork, withGroup); + }; + this._destroy = function () { + return ps('after test'); + }; +}; + +module.exports = context; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../test/context/detached.js"],"names":["cp","require","makepromise","debuglog","path","FORK_PATH","join","__dirname","isWindows","process","platform","createFork","modulePath","detached","env","spawn","argv","execArgv","Object","assign","stdio","getGrep","include","exclude","grep","vgrep","concat","com","push","s","getWmic","procs","map","p","ps","comment","psInclude","psExclude","wmicInclude","exec","then","r","killFork","proc","withGroup","Promise","resolve","reject","once","pid","kill","err","message","context","DetachedContext","fork","epPid","forkNode","exiftoolDetached","EXIFTOOL_DETACHED","on","res","forkPid","Error","_destroy","module","exports"],"mappings":"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","file":"detached.js","sourcesContent":["const cp = require('child_process')\nconst makepromise = require('makepromise')\nconst debuglog = require('util').debuglog('detached')\nconst path = require('path')\n\nconst FORK_PATH = path.join(__dirname, '../fixtures/detached')\n\nconst isWindows = process.platform === 'win32'\n\nconst createFork = (modulePath, detached, env) => cp.spawn(\n    process.argv[0],\n    [modulePath],\n    {\n        detached,\n        // not doing this will not allow debugging, as fork will try to connect\n        // to the same debug port as parent\n        execArgv: [],\n        env: Object.assign({}, process.env, env),\n        stdio: ['pipe', 'pipe', 'pipe', 'ipc'],\n    }\n)\n\nfunction getGrep(include, exclude) {\n    const grep = include.join('\\\\|')\n    const vgrep = [].concat(exclude, 'grep').join('\\\\|')\n    const com = ['ps xao pid,ppid,pgid,stat,sess,tt,tty,command']\n    if (grep) com.push(`grep '${grep}'`)\n    com.push(`grep -v '${vgrep}'`)\n    const s = com.join(' | ')\n    return s\n}\n\nfunction getWmic(include) {\n    const procs = include.map(p => `caption='${p}'`).join(' or ')\n    return `wmic process where \"${procs}\" get caption,processid,parentprocessid`\n}\n\nfunction ps(comment) {\n    const psInclude = ['node', 'perl', 'npm']\n    const psExclude = ['Visual']\n    const wmicInclude = ['node.exe', 'exiftool.exe', 'conhost.exe']\n    const s = isWindows ? getWmic(wmicInclude) : getGrep(psInclude, psExclude)\n    return makepromise(cp.exec, [s])\n        .then((r) => {\n            debuglog(comment)\n            debuglog(`======\\n${r}`)\n            debuglog('======')\n        })\n}\n\nfunction killFork(proc, withGroup) {\n    return new Promise((resolve, reject) => {\n        proc.once('exit', () => {\n            debuglog('killed %s', proc.pid)\n            resolve()\n        })\n        try {\n            const p = withGroup ? -proc.pid : proc.pid\n            debuglog('going to kill %s', p)\n            process.kill(p)\n        } catch(err) {\n            debuglog(err.message)\n            reject(err)\n        }\n    })\n}\n\n/**\n * This context will allow to create and destroy Node fork.\n */\nconst context = function DetachedContext() {\n    this.fork = null\n    this.epPid = null\n\n    this.forkNode = (exiftoolDetached) => {\n        return ps('before starting fork')\n            .then(() => {\n                const env = exiftoolDetached ? { EXIFTOOL_DETACHED: true } : {}\n                this.fork = createFork(FORK_PATH, true, env)\n                debuglog('fork pid: %s', this.fork.pid)\n                return new Promise((resolve) => {\n                    this.fork.on('message', resolve)\n                })\n            })\n            .then((res) => {\n                this.epPid = res\n                debuglog('exiftool pid: %s', this.epPid)\n                this.fork.on('disconnect', () => {\n                    debuglog('fork disconnected')\n                })\n                this.fork.on('exit', () => {\n                    debuglog('fork exited')\n                })\n                return ps('after starting fork')\n            })\n            .then(() => ({ epPid: this.epPid, forkPid: this.fork.pid }))\n    }\n    this.killFork = (withGroup) => {\n        if (!this.fork) {\n            return Promise.reject(new Error('fork has not started'))\n        }\n        return killFork(this.fork, withGroup)\n    }\n    this._destroy = () => ps('after test')\n}\n\nmodule.exports = context\n"]} \ No newline at end of file diff --git a/dist/test/fixtures/detached.js b/dist/test/fixtures/detached.js new file mode 100644 index 0000000..bc851b6 --- /dev/null +++ b/dist/test/fixtures/detached.js @@ -0,0 +1,53 @@ +'use strict'; + +require('source-map-support/register'); + +function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } + +var _require = require('exiftool-context'), + bin = _require.exiftoolBin; + +var exiftool = require('../../src/'); + +if (typeof process.send !== 'function') { + throw new Error('This module should be spawned with an IPC channel.'); +} + +var EXIFTOOL_DETACHED = process.env.EXIFTOOL_DETACHED; + + +var detached = EXIFTOOL_DETACHED === 'true'; + +_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var ep, pid; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + _context.prev = 0; + ep = new exiftool.ExiftoolProcess(bin); + _context.next = 4; + return ep.open({ detached: detached }); + + case 4: + pid = _context.sent; + + process.send(pid); + _context.next = 12; + break; + + case 8: + _context.prev = 8; + _context.t0 = _context['catch'](0); + + console.log(_context.t0); // eslint-disable-line no-console + process.exit(1); + + case 12: + case 'end': + return _context.stop(); + } + } + }, _callee, undefined, [[0, 8]]); +}))(); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Rlc3QvZml4dHVyZXMvZGV0YWNoZWQuanMiXSwibmFtZXMiOlsicmVxdWlyZSIsImJpbiIsImV4aWZ0b29sQmluIiwiZXhpZnRvb2wiLCJwcm9jZXNzIiwic2VuZCIsIkVycm9yIiwiRVhJRlRPT0xfREVUQUNIRUQiLCJlbnYiLCJkZXRhY2hlZCIsImVwIiwiRXhpZnRvb2xQcm9jZXNzIiwib3BlbiIsInBpZCIsImNvbnNvbGUiLCJsb2ciLCJleGl0Il0sIm1hcHBpbmdzIjoiOzs7Ozs7ZUFBNkJBLFFBQVEsa0JBQVIsQztJQUFSQyxHLFlBQWJDLFc7O0FBQ1IsSUFBTUMsV0FBV0gsUUFBUSxZQUFSLENBQWpCOztBQUVBLElBQUksT0FBT0ksUUFBUUMsSUFBZixLQUF3QixVQUE1QixFQUF3QztBQUNwQyxVQUFNLElBQUlDLEtBQUosQ0FBVSxvREFBVixDQUFOO0FBQ0g7O0lBRU9DLGlCLEdBQXNCSCxRQUFRSSxHLENBQTlCRCxpQjs7O0FBRVIsSUFBTUUsV0FBV0Ysc0JBQXNCLE1BQXZDOztBQUVBLHdEQUFDO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBRWFHLHNCQUZiLEdBRWtCLElBQUlQLFNBQVNRLGVBQWIsQ0FBNkJWLEdBQTdCLENBRmxCO0FBQUE7QUFBQSwyQkFHeUJTLEdBQUdFLElBQUgsQ0FBUSxFQUFFSCxrQkFBRixFQUFSLENBSHpCOztBQUFBO0FBR2FJLHVCQUhiOztBQUlPVCw0QkFBUUMsSUFBUixDQUFhUSxHQUFiO0FBSlA7QUFBQTs7QUFBQTtBQUFBO0FBQUE7O0FBTU9DLDRCQUFRQyxHQUFSLGNBTlAsQ0FNd0I7QUFDakJYLDRCQUFRWSxJQUFSLENBQWEsQ0FBYjs7QUFQUDtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxDQUFEIiwiZmlsZSI6ImRldGFjaGVkLmpzIiwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgeyBleGlmdG9vbEJpbjogYmluIH0gPSByZXF1aXJlKCdleGlmdG9vbC1jb250ZXh0JylcbmNvbnN0IGV4aWZ0b29sID0gcmVxdWlyZSgnLi4vLi4vc3JjLycpXG5cbmlmICh0eXBlb2YgcHJvY2Vzcy5zZW5kICE9PSAnZnVuY3Rpb24nKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKCdUaGlzIG1vZHVsZSBzaG91bGQgYmUgc3Bhd25lZCB3aXRoIGFuIElQQyBjaGFubmVsLicpXG59XG5cbmNvbnN0IHsgRVhJRlRPT0xfREVUQUNIRUQgfSA9IHByb2Nlc3MuZW52XG5cbmNvbnN0IGRldGFjaGVkID0gRVhJRlRPT0xfREVUQUNIRUQgPT09ICd0cnVlJztcblxuKGFzeW5jICgpID0+IHtcbiAgICB0cnkge1xuICAgICAgICBjb25zdCBlcCA9IG5ldyBleGlmdG9vbC5FeGlmdG9vbFByb2Nlc3MoYmluKVxuICAgICAgICBjb25zdCBwaWQgPSBhd2FpdCBlcC5vcGVuKHsgZGV0YWNoZWQgfSlcbiAgICAgICAgcHJvY2Vzcy5zZW5kKHBpZClcbiAgICB9IGNhdGNoIChlcnIpIHtcbiAgICAgICAgY29uc29sZS5sb2coZXJyKSAvLyBlc2xpbnQtZGlzYWJsZS1saW5lIG5vLWNvbnNvbGVcbiAgICAgICAgcHJvY2Vzcy5leGl0KDEpXG4gICAgfVxufSkoKVxuIl19 \ No newline at end of file diff --git a/dist/test/lib/kill-pid.js b/dist/test/lib/kill-pid.js new file mode 100644 index 0000000..37ce16b --- /dev/null +++ b/dist/test/lib/kill-pid.js @@ -0,0 +1,46 @@ +'use strict'; + +require('source-map-support/register'); + +var cp = require('child_process'); +var ps = require('ps-node'); + +var isWindows = process.platform === 'win32'; +// use this function when we only have a pid, but not process, i.e., +// we can't assign on('exit') listener +function killUnixPid(pid) { + if (isWindows) { + return Promise.reject(new Error('This function is not available on win')); + } + return new Promise(function (resolve, reject) { + ps.kill(pid, function (err) { + if (err) return reject(err); + return resolve(pid); + }); + }); +} + +function killWinPid(pid) { + if (!isWindows) { + return Promise.reject(new Error('This function is only available on win')); + } + return new Promise(function (resolve, reject) { + cp.exec('taskkill /t /F /PID ' + pid, function (err, stdout) { + if (err) return reject(err); + if (!/SUCCESS/.test(stdout)) return reject(new Error(stdout.trim())); + resolve(pid); + }); + }); +} + +/** + * Kill a process by pid, if pointer is not available. + * @param {number|string} pid Process ID + * @returns {Promise.} Promise resolved with the pid. + */ +function killPid(pid) { + return isWindows ? killWinPid(pid) : killUnixPid(pid); +} + +module.exports = killPid; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/test/spec/begin-ready.js b/dist/test/spec/begin-ready.js new file mode 100644 index 0000000..c3d4a56 --- /dev/null +++ b/dist/test/spec/begin-ready.js @@ -0,0 +1,220 @@ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +require('source-map-support/register'); + +var assert = require('assert'); + +var _require = require('stream'), + Readable = _require.Readable, + Writable = _require.Writable; + +var _require2 = require('../../src/begin-ready'), + createBeginReadyMatchTransformStream = _require2.createBeginReadyMatchTransformStream, + createResolverWriteStream = _require2.createResolverWriteStream, + setupResolveWriteStreamPipe = _require2.setupResolveWriteStreamPipe; + +/** + * Pipe Readable stream in object mode into process.stdout, + * using JSON.stringify to print data. This might results in + * MaxListenersExceededWarning in tests, when process.stdout + * gets assigned a lot of stream listeners such as end, drain, + * error, finish, unpipe, close. + */ +// function debugObjectReadStream(rs, name) { +// rs.pipe(new Transform({ +// objectMode: true, +// transform: (chunk, enc, next) => { +// const s = JSON.stringify(chunk, null, 2) +// console.log(`Some data from ${name} rs: `) +// next(null, `${s}\r\n`) +// }, +// })).pipe(process.stdout) +// } + +var commandNumber = '376080'; +var commandNumber2 = '65754'; + +var data = '\n[{\n "SourceFile": "test/fixtures/CANON/IMG_9857.JPG",\n "ExifToolVersion": 10.25,\n "FileName": "IMG_9857.JPG",\n "Directory": "test/fixtures/CANON",\n "FileSize": "51 kB",\n "FileModifyDate": "2016:05:16 00:25:40+01:00",\n "FileAccessDate": "2016:11:26 01:20:48+00:00",\n "FileInodeChangeDate": "2016:05:16 00:25:40+01:00",\n "FilePermissions": "rw-r--r--",\n "FileType": "JPEG",\n "FileTypeExtension": "jpg",\n "MIMEType": "image/jpeg",\n "XMPToolkit": "Image::ExifTool 10.11",\n "CreatorWorkURL": "https://sobesednik.media",\n "Scene": "011200",\n "Creator": "Photographer Name",\n "ImageWidth": 500,\n "ImageHeight": 333,\n "EncodingProcess": "Baseline DCT, Huffman coding",\n "BitsPerSample": 8,\n "ColorComponents": 3,\n "YCbCrSubSampling": "YCbCr4:2:0 (2 2)",\n "ImageSize": "500x333",\n "Megapixels": 0.167\n}]\n'.trim(); + +var data2 = 'File not found: test/fixtures/no_such_file2.jpg'; + +var s = ('\n{begin' + commandNumber + '}\n' + data + '\n{ready' + commandNumber + '}\n').trim(); + +var s2 = ('\n{begin' + commandNumber2 + '}\n' + data2 + '\n{ready' + commandNumber2 + '}\n').trim(); +var exiftoolOutput = ('\n' + s + '\n' + s2 + '\n').trim(); + +var brtsTestSuite = { + createBeginReadyMatchTransformStream: { + 'should transform match data': function shouldTransformMatchData() { + var rs = new Readable({ objectMode: true }); + rs._read = function () { + var match = { + 1: commandNumber, + 2: data + }; + var match2 = { + 1: commandNumber2, + 2: data2 + }; + rs.push(match); + rs.push(match2); + rs.push(null); + }; + var brts = createBeginReadyMatchTransformStream(); + + return new Promise(function (resolve, reject) { + var ws = new Writable({ objectMode: true }); + var data = []; + ws._write = function (chunk, enc, next) { + data.push(chunk); + next(); + }; + ws.on('finish', function () { + resolve(data); + }); + ws.on('error', reject); + rs.pipe(brts).pipe(ws); + }).then(function (res) { + assert.equal(res.length, 2); + + var _res = _slicedToArray(res, 2), + output = _res[0], + output2 = _res[1]; + + assert.equal(output.cn, commandNumber); + assert.equal(output.d, data); + assert.equal(output2.cn, commandNumber2); + assert.equal(output2.d, data2); + }); + } + }, + createResolverWriteStream: { + 'should have _resolveMap property': function shouldHave_resolveMapProperty() { + var rws = createResolverWriteStream(); + assert.equal(_typeof(rws._resolveMap), 'object'); + }, + 'should have addToResolveMap function': function shouldHaveAddToResolveMapFunction() { + var rws = createResolverWriteStream(); + assert.equal(_typeof(rws.addToResolveMap), 'function'); + }, + 'should add resolve function to the map': function shouldAddResolveFunctionToTheMap() { + var rws = createResolverWriteStream(); + var handler = function handler() {}; + rws.addToResolveMap(commandNumber, handler); + assert.strictEqual(rws._resolveMap[commandNumber], handler); + }, + 'should throw an error when resolve is not a function': function shouldThrowAnErrorWhenResolveIsNotAFunction() { + var rws = createResolverWriteStream(); + assert.throws(function () { + return rws.addToResolveMap(commandNumber); + }, /resolve argument must be a function/); + }, + 'should throw an error when commandNumber is not a string': function shouldThrowAnErrorWhenCommandNumberIsNotAString() { + var rws = createResolverWriteStream(); + assert.throws(function () { + return rws.addToResolveMap(); + }, /commandNumber argument must be a string/); + }, + 'should throw an error when key already exists in the map': function shouldThrowAnErrorWhenKeyAlreadyExistsInTheMap() { + var rws = createResolverWriteStream(); + var handler = function handler() {}; + rws.addToResolveMap(commandNumber, handler); + assert.throws(function () { + return rws.addToResolveMap(commandNumber, handler); + }, /Command with the same number is already expected/); + }, + 'should call resolve and delete entry from resolveMap on data': function shouldCallResolveAndDeleteEntryFromResolveMapOnData() { + var rs = new Readable({ objectMode: true }); + rs._read = function () { + rs.push({ + cn: commandNumber, + d: data + }); + rs.push({ + cn: commandNumber2, + d: data2 + }); + rs.push(null); + }; + var results = []; + var handler = function handler(data) { + return results.push(data); + }; + var rws = createResolverWriteStream(); + rws.addToResolveMap(commandNumber, handler); + rws.addToResolveMap(commandNumber2, handler); + + rs.pipe(rws); + + return new Promise(function (resolve) { + return rws.on('finish', resolve); + }).then(function () { + assert.equal(results.length, 2); + assert.equal(results[0], data); + assert.equal(results[1], data2); + assert(!Object.keys(rws._resolveMap).length); + }); + }, + 'should call next with an error when command number cannot be found': function shouldCallNextWithAnErrorWhenCommandNumberCannotBeFound() { + var rs = new Readable({ objectMode: true }); + rs._read = function () { + rs.push({ + cn: commandNumber, + d: data + }); + rs.push({ + cn: commandNumber2, + d: data2 + }); + rs.push(null); + }; + var results = []; + var handler = function handler(data) { + return results.push(data); + }; + var rws = createResolverWriteStream(); + rws.addToResolveMap(commandNumber, handler); + + rs.pipe(rws); + + return new Promise(function (resolve) { + return rws.on('error', resolve); + }).then(function (err) { + assert.equal(err.message, 'Command with index ' + commandNumber2 + ' not found'); + assert.equal(results.length, 1); + assert.equal(results[0], data); + }); + } + }, + setupResolveWriteStreamPipe: { + 'should pipe exiftool data and call resolve functions': function shouldPipeExiftoolDataAndCallResolveFunctions() { + var rs = new Readable(); + rs._read = function () { + rs.push(exiftoolOutput); + rs.push(null); + }; + var results = []; + var rws = setupResolveWriteStreamPipe(rs); + rws.addToResolveMap(commandNumber, function (data) { + return results.push(data); + }); + rws.addToResolveMap(commandNumber2, function (data) { + return results.push(data); + }); + return new Promise(function (resolve) { + return rws.on('finish', resolve); + }).then(function () { + assert.equal(results.length, 2); + assert.equal(results[0], data); + assert.equal(results[1], data2); + }); + } + } +}; + +module.exports = brtsTestSuite; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../test/spec/begin-ready.js"],"names":["assert","require","Readable","Writable","createBeginReadyMatchTransformStream","createResolverWriteStream","setupResolveWriteStreamPipe","commandNumber","commandNumber2","data","trim","data2","s","s2","exiftoolOutput","brtsTestSuite","rs","objectMode","_read","match","match2","push","brts","Promise","resolve","reject","ws","_write","chunk","enc","next","on","pipe","then","res","equal","length","output","output2","cn","d","rws","_resolveMap","addToResolveMap","handler","strictEqual","throws","results","Object","keys","err","message","module","exports"],"mappings":"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","file":"begin-ready.js","sourcesContent":["const assert = require('assert')\nconst { Readable, Writable } = require('stream')\nconst {\n    createBeginReadyMatchTransformStream,\n    createResolverWriteStream,\n    setupResolveWriteStreamPipe,\n} = require('../../src/begin-ready')\n\n/**\n * Pipe Readable stream in object mode into process.stdout,\n * using JSON.stringify to print data. This might results in\n * MaxListenersExceededWarning in tests, when process.stdout\n * gets assigned a lot of stream listeners such as end, drain,\n * error, finish, unpipe, close.\n */\n// function debugObjectReadStream(rs, name) {\n//     rs.pipe(new Transform({\n//         objectMode: true,\n//         transform: (chunk, enc, next) => {\n//             const s = JSON.stringify(chunk, null, 2)\n//             console.log(`Some data from ${name} rs: `)\n//             next(null, `${s}\\r\\n`)\n//         },\n//     })).pipe(process.stdout)\n// }\n\nconst commandNumber = '376080'\nconst commandNumber2 = '65754'\n\nconst data = `\n[{\n  \"SourceFile\": \"test/fixtures/CANON/IMG_9857.JPG\",\n  \"ExifToolVersion\": 10.25,\n  \"FileName\": \"IMG_9857.JPG\",\n  \"Directory\": \"test/fixtures/CANON\",\n  \"FileSize\": \"51 kB\",\n  \"FileModifyDate\": \"2016:05:16 00:25:40+01:00\",\n  \"FileAccessDate\": \"2016:11:26 01:20:48+00:00\",\n  \"FileInodeChangeDate\": \"2016:05:16 00:25:40+01:00\",\n  \"FilePermissions\": \"rw-r--r--\",\n  \"FileType\": \"JPEG\",\n  \"FileTypeExtension\": \"jpg\",\n  \"MIMEType\": \"image/jpeg\",\n  \"XMPToolkit\": \"Image::ExifTool 10.11\",\n  \"CreatorWorkURL\": \"https://sobesednik.media\",\n  \"Scene\": \"011200\",\n  \"Creator\": \"Photographer Name\",\n  \"ImageWidth\": 500,\n  \"ImageHeight\": 333,\n  \"EncodingProcess\": \"Baseline DCT, Huffman coding\",\n  \"BitsPerSample\": 8,\n  \"ColorComponents\": 3,\n  \"YCbCrSubSampling\": \"YCbCr4:2:0 (2 2)\",\n  \"ImageSize\": \"500x333\",\n  \"Megapixels\": 0.167\n}]\n`\n    .trim()\n\nconst data2 = 'File not found: test/fixtures/no_such_file2.jpg'\n\nconst s = `\n{begin${commandNumber}}\n${data}\n{ready${commandNumber}}\n`\n    .trim()\n\nconst s2 = `\n{begin${commandNumber2}}\n${data2}\n{ready${commandNumber2}}\n`\n    .trim()\nconst exiftoolOutput = `\n${s}\n${s2}\n`\n    .trim()\n\nconst brtsTestSuite = {\n    createBeginReadyMatchTransformStream: {\n        'should transform match data': () => {\n            const rs = new Readable({ objectMode: true })\n            rs._read = () => {\n                const match = {\n                    1: commandNumber,\n                    2: data,\n                }\n                const match2 = {\n                    1: commandNumber2,\n                    2: data2,\n                }\n                rs.push(match)\n                rs.push(match2)\n                rs.push(null)\n            }\n            const brts = createBeginReadyMatchTransformStream()\n\n            return new Promise((resolve, reject) => {\n                const ws = new Writable({ objectMode: true })\n                const data = []\n                ws._write = (chunk, enc, next) => {\n                    data.push(chunk)\n                    next()\n                }\n                ws.on('finish', () => { resolve(data) })\n                ws.on('error', reject)\n                rs.pipe(brts).pipe(ws)\n            })\n                .then((res) => {\n                    assert.equal(res.length, 2)\n                    const [output, output2] = res\n                    assert.equal(output.cn, commandNumber)\n                    assert.equal(output.d, data)\n                    assert.equal(output2.cn, commandNumber2)\n                    assert.equal(output2.d, data2)\n                })\n        },\n    },\n    createResolverWriteStream: {\n        'should have _resolveMap property': () => {\n            const rws = createResolverWriteStream()\n            assert.equal(typeof rws._resolveMap, 'object')\n        },\n        'should have addToResolveMap function': () => {\n            const rws = createResolverWriteStream()\n            assert.equal(typeof rws.addToResolveMap, 'function')\n        },\n        'should add resolve function to the map': () => {\n            const rws = createResolverWriteStream()\n            const handler = () => {}\n            rws.addToResolveMap(commandNumber, handler)\n            assert.strictEqual(rws._resolveMap[commandNumber], handler)\n        },\n        'should throw an error when resolve is not a function': () => {\n            const rws = createResolverWriteStream()\n            assert.throws(\n                () => rws.addToResolveMap(commandNumber),\n                /resolve argument must be a function/\n            )\n        },\n        'should throw an error when commandNumber is not a string': () => {\n            const rws = createResolverWriteStream()\n            assert.throws(\n                () => rws.addToResolveMap(),\n                /commandNumber argument must be a string/\n            )\n        },\n        'should throw an error when key already exists in the map': () => {\n            const rws = createResolverWriteStream()\n            const handler = () => {}\n            rws.addToResolveMap(commandNumber, handler)\n            assert.throws(\n                () => rws.addToResolveMap(commandNumber, handler),\n                /Command with the same number is already expected/\n            )\n        },\n        'should call resolve and delete entry from resolveMap on data': () => {\n            const rs = new Readable({ objectMode: true})\n            rs._read = () => {\n                rs.push({\n                    cn: commandNumber,\n                    d: data,\n                })\n                rs.push({\n                    cn: commandNumber2,\n                    d: data2,\n                })\n                rs.push(null)\n            }\n            const results = []\n            const handler = (data) => results.push(data)\n            const rws = createResolverWriteStream()\n            rws.addToResolveMap(commandNumber, handler)\n            rws.addToResolveMap(commandNumber2, handler)\n\n            rs.pipe(rws)\n\n            return new Promise(resolve => rws.on('finish', resolve))\n                .then(() => {\n                    assert.equal(results.length, 2)\n                    assert.equal(results[0], data)\n                    assert.equal(results[1], data2)\n                    assert(!Object.keys(rws._resolveMap).length)\n                })\n        },\n        'should call next with an error when command number cannot be found': () => {\n            const rs = new Readable({ objectMode: true})\n            rs._read = () => {\n                rs.push({\n                    cn: commandNumber,\n                    d: data,\n                })\n                rs.push({\n                    cn: commandNumber2,\n                    d: data2,\n                })\n                rs.push(null)\n            }\n            const results = []\n            const handler = (data) => results.push(data)\n            const rws = createResolverWriteStream()\n            rws.addToResolveMap(commandNumber, handler)\n\n            rs.pipe(rws)\n\n            return new Promise(resolve => rws.on('error', resolve))\n                .then((err) => {\n                    assert.equal(err.message, `Command with index ${commandNumber2} not found`)\n                    assert.equal(results.length, 1)\n                    assert.equal(results[0], data)\n                })\n        },\n    },\n    setupResolveWriteStreamPipe: {\n        'should pipe exiftool data and call resolve functions': () => {\n            const rs = new Readable\n            rs._read = () => {\n                rs.push(exiftoolOutput)\n                rs.push(null)\n            }\n            const results = []\n            const rws = setupResolveWriteStreamPipe(rs)\n            rws.addToResolveMap(commandNumber, (data) => results.push(data))\n            rws.addToResolveMap(commandNumber2, (data) => results.push(data))\n            return new Promise(resolve => rws.on('finish', resolve))\n                .then(() => {\n                    assert.equal(results.length, 2)\n                    assert.equal(results[0], data)\n                    assert.equal(results[1], data2)\n                })\n        },\n    },\n}\n\nmodule.exports = brtsTestSuite\n"]} \ No newline at end of file diff --git a/dist/test/spec/codedcharacterset.js b/dist/test/spec/codedcharacterset.js new file mode 100644 index 0000000..7dc12f0 --- /dev/null +++ b/dist/test/spec/codedcharacterset.js @@ -0,0 +1,53 @@ +'use strict'; + +require('source-map-support/register'); + +var assert = require('assert'); + +var _require = require('os'), + EOL = _require.EOL; + +var context = require('exiftool-context'); +var exiftool = require('../../src/'); +context.globalExiftoolConstructor = exiftool.ExiftoolProcess; + +var metadata = { + all: '', // remove all metadata at first + Title: 'åäö', + LocalCaption: 'local caption', + 'Caption-Abstract': 'C\xE2pt\xEF\xF6n \xC3bstr\xE1ct: \xE5\xE4\xF6', + Copyright: '2017 ©', + 'Keywords+': ['k\xEByw\xF4rd \xC3\u2026', 'keywórdB ©˙µå≥'], + Creator: 'Mr Author', + Rating: 5 +}; + +var IPTCEncoding = { + context: context, + 'should raise a warning when codedcharacterset=utf8 not provided for IPTC tags': function shouldRaiseAWarningWhenCodedcharactersetUtf8NotProvidedForIPTCTags(ctx) { + return ctx.createTempFile().then(function () { + return ctx.initAndWriteMetadata(ctx.tempFile, metadata); + }).then(function (res) { + assert.equal(res.data, null); + var expected = 'Warning: Some character(s) could not be encoded in Latin - ' + ctx.replaceSlashes(ctx.tempFile) + EOL + ' 1 image files updated'; + assert.equal(res.error, expected); + }); + }, + 'should successfully update the file when codedcharacterset=utf8 passed': function shouldSuccessfullyUpdateTheFileWhenCodedcharactersetUtf8Passed(ctx) { + var args = ['codedcharacterset=utf8']; + return ctx.createTempFile().then(function () { + return ctx.initAndWriteMetadata(ctx.tempFile, metadata, args); + }).then(function (res) { + assert.equal(res.data, null); + var expected = '1 image files updated'; + assert.equal(res.error, expected); + }); + } +}; + +module.exports = { + codedcharacterset: { + IPTCEncoding: IPTCEncoding + } +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/test/spec/constructor.js b/dist/test/spec/constructor.js new file mode 100644 index 0000000..9f87986 --- /dev/null +++ b/dist/test/spec/constructor.js @@ -0,0 +1,30 @@ +'use strict'; + +require('source-map-support/register'); + +var assert = require('assert'); +var context = require('exiftool-context'); +var exiftool = require('../../src/'); +context.globalExiftoolConstructor = exiftool.ExiftoolProcess; + +var constructorTestSuite = { + context: context, + 'creates new ExiftoolProcess instance with default bin': function createsNewExiftoolProcessInstanceWithDefaultBin(ctx) { + var ep = new exiftool.ExiftoolProcess(); + assert(ep instanceof exiftool.ExiftoolProcess); + assert.equal(ep._bin, exiftool.EXIFTOOL_PATH); + assert.equal(ep._bin, ctx.defaultBin); + }, + 'instance\'s isOpen getter returns false': function instanceSIsOpenGetterReturnsFalse(ctx) { + ctx.create(); + assert(!ctx.ep.isOpen); + }, + 'creates new ExiftoolProcess object with specific bin': function createsNewExiftoolProcessObjectWithSpecificBin(ctx) { + var bin = '/usr/local/my-exiftool'; + ctx.create(bin); + assert.equal(ctx.ep._bin, bin); + } +}; + +module.exports = constructorTestSuite; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/test/spec/detached-true.js b/dist/test/spec/detached-true.js new file mode 100644 index 0000000..119385f --- /dev/null +++ b/dist/test/spec/detached-true.js @@ -0,0 +1,236 @@ +'use strict'; + +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +require('source-map-support/register'); + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var makepromise = require('makepromise'); +var ps = require('ps-node'); +var assert = require('assert'); +var killPid = require('../lib/kill-pid'); + +var exiftool = require('../../src/'); +var context = require('../context/detached'); +context.globalExiftoolConstructor = exiftool.ExiftoolProcess; + +var isWindows = process.platform === 'win32'; + +var checkPid = function checkPid(pid) { + return makepromise(ps.lookup, { pid: pid }); +}; +var checkPpid = function checkPpid(ppid) { + return makepromise(ps.lookup, { ppid: ppid }); +}; + +/** + * @typedef {Object} PSRes + * @property {string} pid + * @property {string} command + * @property {string[]} arguments + * @property {string} ppid + */ + +/** + * @typedef {Object} CheckPidsRes + * @property {PSRes} [fork] + * @property {PSRes} [ep] + * @property {PSRes} [epChild] + * @property {PSRes} [conhost] + */ + +/** + * @typedef {function(): Promise.} CheckPidsFn + */ + +/** + * Create checkPids function. + * @param {string|number} forkPid pid of Node fork + * @param {string|number} epPid exiftool pid + * @param {string|number} [epChildPid] on windows, child ep pid + * @param {string|number} [conhostPid] on windows, child conhost pid + * @returns {CheckPidsFn} Function to check pids with ps-node + */ +function createCheckPids(forkPid, epPid, epChildPid, conhostPid) { + assert(forkPid); + assert(epPid); + var arr = [forkPid, epPid]; + if (epChildPid) arr.push(epChildPid); + if (conhostPid) arr.push(conhostPid); + var checkPids = function checkPids() { + return checkPid(arr).then(function (res) { + var fork = res.find(function (r) { + return r.pid === '' + forkPid; + }); + var ep = res.find(function (r) { + return r.pid === '' + epPid; + }); + var epChild = epChildPid ? res.find(function (r) { + return r.pid === '' + epChildPid; + }) : undefined; + var conhost = conhostPid ? res.find(function (r) { + return r.pid === '' + conhostPid; + }) : undefined; + var o = { + fork: fork, + ep: ep, + epChild: epChild, + conhost: conhost + // filter out undefined + };var fo = Object.keys(o).reduce(function (acc, key) { + var value = o[key]; + if (value === undefined) { + return acc; + } + return Object.assign({}, acc, _defineProperty({}, key, value)); + }, {}); + return fo; + }); + }; + return checkPids; +} + +var findExiftoolChildAndConhost = function findExiftoolChildAndConhost(epPid, exiftoolDetached) { + if (!isWindows) { + return Promise.reject(new Error('This function is only available on Windows')); + } + return checkPpid(epPid).then(function (res) { + // if not detached, conhost is child of parent exiftool, + // which is already found above + if (!exiftoolDetached) return res; + // if detached, conhost is child of child exiftool, + // which we are now finding + + var _res = _slicedToArray(res, 1), + childExiftool = _res[0]; + + assert(childExiftool); + assert(/exiftool\.exe/.test(childExiftool.command)); + return checkPpid(childExiftool.pid).then(function (conhostRes) { + var _conhostRes = _slicedToArray(conhostRes, 1), + conhost = _conhostRes[0]; + + assert(conhost); + assert(/conhost.exe/.test(conhost.command)); + var all = [].concat(conhostRes, res); + return all; + }); + }).then(function (res) { + assert.equal(res.length, 2); + var conhost = res.find(function (p) { + return (/conhost\.exe/.test(p.command) + ); + }); + assert(conhost, 'conhost.exe should have been started as child of exiftool'); + var conhostPid = conhost.pid; + var epChild = res.find(function (p) { + return (/exiftool\.exe/.test(p.command) + ); + }); + assert(epChild, 'exiftool.exe should have been started as child of exiftool'); + var epChildPid = epChild.pid; + return { conhostPid: conhostPid, epChildPid: epChildPid }; + }); +}; + +/** + * Fork a node process with a module which will spawn exiftool. Because of the + * way exiftool works on Windows, it will spawn an extra process itself. + * @param {boolean} exiftoolDetached Whether to start exiftool in detached mode + * @returns {CheckPidsFn} A scoped function to check pids + */ +var setup = function setup(exiftoolDetached, ctx) { + var checkPids = void 0; + + return ctx.forkNode(exiftoolDetached).then(function (_ref) { + var forkPid = _ref.forkPid, + epPid = _ref.epPid; + + var res = { forkPid: forkPid, epPid: epPid }; + + if (isWindows) { + return findExiftoolChildAndConhost(epPid, exiftoolDetached).then(function (r) { + return Object.assign(res, r); + }); + } + return res; + }).then(function (res) { + checkPids = createCheckPids(res.forkPid, res.epPid, res.epChildPid, res.conhostPid); + return checkPids(); + }).then(function (res) { + assert(res.fork); + assert(res.ep); + if (isWindows) { + assert(res.epChild); + assert(res.conhost); + } + return checkPids; + }); +}; + +var createTestWin = function createTestWin(detached) { + var test = function test(ctx) { + var checkPids = void 0; + return setup(detached, ctx).then(function (res) { + checkPids = res; + return ctx.killFork().then(checkPids); + }).then(function (res) { + assert(!res.fork, 'Node fork should have quit'); + assert(res.epChild, 'Exiftool child should stay open'); + assert(res.conhost, 'conhost should stay open'); + + if (detached) { + assert(res.ep, 'Exiftool parent should stay open'); + } else { + assert(!res.ep, 'Exiftool parent should have quit'); + } + + // cleanup by killing child exiftool, this should kill the whole tree + return killPid(res.epChild.pid); + }); + }; + return test; +}; + +var createTest = function createTest(detached) { + var test = function test(ctx) { + var checkPids = void 0; + return setup(detached, ctx).then(function (res) { + checkPids = res; + return ctx.killFork(true).then(checkPids); + }).then(function (res) { + assert(!res.fork, 'Node fork should have quit'); + + if (detached) { + assert(res.ep, 'Exiftool parent should stay open'); + return killPid(res.ep.pid); + } else { + assert(!res.ep, 'Exiftool parent should have quit'); + } + }); + }; + return test; +}; + +var DetachedTrueTestSuite = {}; + +if (isWindows) { + Object.assign(DetachedTrueTestSuite, { + context: context, + 'should quit child process when fork exits without detached option (win)': createTestWin(), + 'should not quit child process when fork exits with detached option (win)': createTestWin(true) + }); +} else { + Object.assign(DetachedTrueTestSuite, { + context: context, + // Also note: on Linux, child processes of child processes will not be terminated when attempting to kill their parent. + // kill detached fork by passing -pid (i.e., pgid) + // https://nodejs.org/api/child_process.html#child_process_subprocess_kill_signal + 'should quit child process when fork exits without detached option': createTest(), + 'should not quit child process when fork exits with detached option': createTest(true) + }); +} + +module.exports = DetachedTrueTestSuite; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../test/spec/detached-true.js"],"names":["makepromise","require","ps","assert","killPid","exiftool","context","globalExiftoolConstructor","ExiftoolProcess","isWindows","process","platform","checkPid","lookup","pid","checkPpid","ppid","createCheckPids","forkPid","epPid","epChildPid","conhostPid","arr","push","checkPids","then","res","fork","find","r","ep","epChild","undefined","conhost","o","fo","Object","keys","reduce","acc","key","value","assign","findExiftoolChildAndConhost","exiftoolDetached","Promise","reject","Error","childExiftool","test","command","conhostRes","all","concat","equal","length","p","setup","ctx","forkNode","createTestWin","detached","killFork","createTest","DetachedTrueTestSuite","module","exports"],"mappings":"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","file":"detached-true.js","sourcesContent":["const makepromise = require('makepromise')\nconst ps = require('ps-node')\nconst assert = require('assert')\nconst killPid = require('../lib/kill-pid')\n\nconst exiftool = require('../../src/')\nconst context = require('../context/detached')\ncontext.globalExiftoolConstructor = exiftool.ExiftoolProcess\n\nconst isWindows = process.platform === 'win32'\n\nconst checkPid = pid => makepromise(ps.lookup, { pid })\nconst checkPpid = ppid => makepromise(ps.lookup, { ppid })\n\n/**\n * @typedef {Object} PSRes\n * @property {string} pid\n * @property {string} command\n * @property {string[]} arguments\n * @property {string} ppid\n */\n\n/**\n * @typedef {Object} CheckPidsRes\n * @property {PSRes} [fork]\n * @property {PSRes} [ep]\n * @property {PSRes} [epChild]\n * @property {PSRes} [conhost]\n */\n\n/**\n * @typedef {function(): Promise.<CheckPidsRes>} CheckPidsFn\n */\n\n/**\n * Create checkPids function.\n * @param {string|number} forkPid pid of Node fork\n * @param {string|number} epPid exiftool pid\n * @param {string|number} [epChildPid] on windows, child ep pid\n * @param {string|number} [conhostPid] on windows, child conhost pid\n * @returns {CheckPidsFn} Function to check pids with ps-node\n */\nfunction createCheckPids(forkPid, epPid, epChildPid, conhostPid) {\n    assert(forkPid)\n    assert(epPid)\n    const arr = [forkPid, epPid]\n    if (epChildPid) arr.push(epChildPid)\n    if (conhostPid) arr.push(conhostPid)\n    const checkPids = () => checkPid(arr)\n        .then((res) => {\n            const fork = res.find(r => r.pid === `${forkPid}`)\n            const ep = res.find(r => r.pid === `${epPid}`)\n            const epChild = epChildPid ? res.find(r => r.pid === `${epChildPid}`) : undefined\n            const conhost = conhostPid ? res.find(r => r.pid === `${conhostPid}`) : undefined\n            const o = {\n                fork,\n                ep,\n                epChild,\n                conhost,\n            }\n            // filter out undefined\n            const fo = Object.keys(o).reduce((acc, key) => {\n                const value = o[key]\n                if (value === undefined) {\n                    return acc\n                }\n                return Object.assign({}, acc, {\n                    [key]: value,\n                })\n            }, {})\n            return fo\n        })\n    return checkPids\n}\n\nconst findExiftoolChildAndConhost = (epPid, exiftoolDetached) => {\n    if (!isWindows) {\n        return Promise.reject(new Error('This function is only available on Windows'))\n    }\n    return checkPpid(epPid)\n        .then((res) => {\n            // if not detached, conhost is child of parent exiftool,\n            // which is already found above\n            if (!exiftoolDetached) return res\n            // if detached, conhost is child of child exiftool,\n            // which we are now finding\n            const [childExiftool] = res\n            assert(childExiftool)\n            assert(/exiftool\\.exe/.test(childExiftool.command))\n            return checkPpid(childExiftool.pid).then((conhostRes) => {\n                const [conhost] = conhostRes\n                assert(conhost)\n                assert(/conhost.exe/.test(conhost.command))\n                const all = [].concat(conhostRes, res)\n                return all\n            })\n        })\n        .then((res) => {\n            assert.equal(res.length, 2)\n            const conhost = res.find(p => /conhost\\.exe/.test(p.command))\n            assert(conhost, 'conhost.exe should have been started as child of exiftool')\n            const conhostPid = conhost.pid\n            const epChild = res.find(p => /exiftool\\.exe/.test(p.command))\n            assert(epChild, 'exiftool.exe should have been started as child of exiftool')\n            const epChildPid = epChild.pid\n            return { conhostPid, epChildPid }\n        })\n}\n\n/**\n * Fork a node process with a module which will spawn exiftool. Because of the\n * way exiftool works on Windows, it will spawn an extra process itself.\n * @param {boolean} exiftoolDetached Whether to start exiftool in detached mode\n * @returns {CheckPidsFn} A scoped function to check pids\n */\nconst setup = (exiftoolDetached, ctx) => {\n    let checkPids\n\n    return ctx.forkNode(exiftoolDetached)\n        .then(({ forkPid, epPid }) => {\n            const res = { forkPid, epPid }\n\n            if (isWindows) {\n                return findExiftoolChildAndConhost(epPid, exiftoolDetached)\n                    .then(r => Object.assign(res, r))\n            }\n            return res\n        })\n        .then((res) => {\n            checkPids = createCheckPids(res.forkPid, res.epPid, res.epChildPid, res.conhostPid)\n            return checkPids()\n        })\n        .then((res) => {\n            assert(res.fork)\n            assert(res.ep)\n            if (isWindows) {\n                assert(res.epChild)\n                assert(res.conhost)\n            }\n            return checkPids\n        })\n}\n\nconst createTestWin = (detached) => {\n    const test = (ctx) => {\n        let checkPids\n        return setup(detached, ctx)\n            .then((res) => {\n                checkPids = res\n                return ctx.killFork().then(checkPids)\n            })\n            .then((res) => {\n                assert(!res.fork, 'Node fork should have quit')\n                assert(res.epChild, 'Exiftool child should stay open')\n                assert(res.conhost, 'conhost should stay open')\n\n                if (detached) {\n                    assert(res.ep, 'Exiftool parent should stay open')\n                } else {\n                    assert(!res.ep, 'Exiftool parent should have quit')\n                }\n\n                // cleanup by killing child exiftool, this should kill the whole tree\n                return killPid(res.epChild.pid)\n            })\n    }\n    return test\n}\n\nconst createTest = (detached) => {\n    const test = (ctx) => {\n        let checkPids\n        return setup(detached, ctx)\n            .then((res) => {\n                checkPids = res\n                return ctx.killFork(true).then(checkPids)\n            })\n            .then((res) => {\n                assert(!res.fork, 'Node fork should have quit')\n\n                if (detached) {\n                    assert(res.ep, 'Exiftool parent should stay open')\n                    return killPid(res.ep.pid)\n                } else {\n                    assert(!res.ep, 'Exiftool parent should have quit')\n                }\n            })\n    }\n    return test\n}\n\nconst DetachedTrueTestSuite = {}\n\nif (isWindows) {\n    Object.assign(DetachedTrueTestSuite, {\n        context,\n        'should quit child process when fork exits without detached option (win)': createTestWin(),\n        'should not quit child process when fork exits with detached option (win)': createTestWin(true),\n    })\n} else {\n    Object.assign(DetachedTrueTestSuite, {\n        context,\n        // Also note: on Linux, child processes of child processes will not be terminated when attempting to kill their parent.\n        // kill detached fork by passing -pid (i.e., pgid)\n        // https://nodejs.org/api/child_process.html#child_process_subprocess_kill_signal\n        'should quit child process when fork exits without detached option': createTest(),\n        'should not quit child process when fork exits with detached option': createTest(true),\n    })\n}\n\n\nmodule.exports = DetachedTrueTestSuite\n"]} \ No newline at end of file diff --git a/dist/test/spec/exiftool.js b/dist/test/spec/exiftool.js new file mode 100644 index 0000000..93652e3 --- /dev/null +++ b/dist/test/spec/exiftool.js @@ -0,0 +1,279 @@ +'use strict'; + +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +require('source-map-support/register'); + +var _require = require('os'), + EOL = _require.EOL; + +var assert = require('assert'); +var child_process = require('child_process'); +var context = require('exiftool-context'); +var exiftool = require('../../src/'); +context.globalExiftoolConstructor = exiftool.ExiftoolProcess; + +var ChildProcess = child_process.ChildProcess; + + +var exiftoolTestSuite = { + context: context, + open: { + 'opens exiftool': function opensExiftool(ctx) { + return ctx.createOpen().then(function (pid) { + assert(ctx.ep._process instanceof ChildProcess); + assert(ctx.ep._process.stdout.readable); + assert(ctx.ep._process.stderr.readable); + assert(ctx.ep._process.stdin.writable); + assert(ctx.ep.isOpen); + assert.equal(typeof pid === 'undefined' ? 'undefined' : _typeof(pid), 'number'); + assert.equal(pid, ctx.ep._process.pid); + }); + }, + 'returns rejected promise when exiftool executable not found': function returnsRejectedPromiseWhenExiftoolExecutableNotFound(ctx) { + return ctx.createOpen('notexiftool').then(function () { + throw new Error('open should have resulted in error'); + }, function (err) { + assert.equal(err.message, 'spawn notexiftool ENOENT'); + }); + }, + 'emits OPEN event with PID': function emitsOPENEventWithPID(ctx) { + ctx.create(); + var eventPromise = new Promise(function (resolve) { + return ctx.ep.on(exiftool.events.OPEN, resolve); + }); + return ctx.open().then(function () { + return eventPromise; + }).then(function (pid) { + return assert.equal(pid, ctx.ep._process.pid); + }); + }, + 'returns rejected promise when process is open already': function returnsRejectedPromiseWhenProcessIsOpenAlready(ctx) { + return ctx.createOpen().then(function () { + return ctx.open(); + }).then(function () { + throw new Error('second open should have resulted in error'); + }, function (err) { + assert.equal(err.message, 'Exiftool process is already open'); + }); + } + }, + close: { + 'closes the process': function closesTheProcess(ctx) { + return ctx.createOpen().then(function () { + return ctx.close(); + }).then(function () { + assert(ctx.ep._process instanceof ChildProcess); + assert(!ctx.ep._process.stdout.readable); + assert(!ctx.ep._process.stderr.readable); + assert(!ctx.ep._process.stdin.writable); + assert(!ctx.ep.isOpen); + }); + }, + 'updates resolve write streams to be finished': function updatesResolveWriteStreamsToBeFinished(ctx) { + return ctx.createOpen().then(function () { + return ctx.close(); + }).then(function () { + assert(ctx.ep._stdoutResolveWs._writableState.finished); + assert(ctx.ep._stderrResolveWs._writableState.finished); + }); + }, + 'completes remaining jobs': function completesRemainingJobs(ctx) { + return ctx.createOpen().then(function () { + var p = ctx.ep.readMetadata(ctx.jpegFile).then(function (res) { + assert(Array.isArray(res.data)); + assert.equal(res.error, null); + res.data.forEach(ctx.assertJpegMetadata); + }); + var p2 = ctx.ep.readMetadata(ctx.jpegFile2).then(function (res) { + assert(Array.isArray(res.data)); + assert.equal(res.error, null); + res.data.forEach(ctx.assertJpegMetadata); + }); + var readPromises = Promise.all([p, p2]); + + return ctx.close().then(function () { + assert(!Object.keys(ctx.ep._stdoutResolveWs._resolveMap).length); + assert(!Object.keys(ctx.ep._stderrResolveWs._resolveMap).length); + }).then(function () { + return readPromises; + }); + }); + }, + 'emits EXIT event': function emitsEXITEvent(ctx) { + ctx.create(); + var eventPromise = new Promise(function (resolve) { + return ctx.ep.on(exiftool.events.EXIT, resolve); + }); + return ctx.open().then(function () { + return ctx.close(); + }).then(function () { + return eventPromise; + }); + }, + 'sets open to false': function setsOpenToFalse(ctx) { + return ctx.createOpen().then(function () { + return ctx.close(); + }).then(function () { + return assert(!ctx.ep.isOpen); + }); + }, + 'returns rejected promise when process not open': function returnsRejectedPromiseWhenProcessNotOpen(ctx) { + return ctx.create().close().then(function () { + throw new Error('close should have resulted in error'); + }, function (err) { + assert.equal(err.message, 'Exiftool process is not open'); + }); + } + }, + readMetadata: { + 'returns rejected promise when trying to execute when not open': function returnsRejectedPromiseWhenTryingToExecuteWhenNotOpen(ctx) { + return ctx.create().readMetadata(ctx.jpegFile).then(function () { + throw new Error('readMetadata should have resulted in error'); + }).catch(function (err) { + return assert.equal(err.message, 'exiftool is not open'); + }); + }, + 'reads metadata of files in a directory': function readsMetadataOfFilesInADirectory(ctx) { + return ctx.initAndReadMetadata(ctx.folder).then(function (res) { + assert(Array.isArray(res.data)); + assert.equal(res.data.length, 5); + res.data.forEach(ctx.assertJpegMetadata); + assert.equal(res.error, '1 directories scanned' + EOL + ' 5 image files read'); + }); + }, + 'returns null data for empty directory and info error': function returnsNullDataForEmptyDirectoryAndInfoError(ctx) { + return ctx.initAndReadMetadata(ctx.emptyFolder).then(function (res) { + assert.equal(res.data, null); + assert.equal(res.error, '1 directories scanned' + EOL + ' 0 image files read'); + }); + }, + 'allows to specify arguments': function allowsToSpecifyArguments(ctx) { + return ctx.initAndReadMetadata(ctx.jpegFile, ['Orientation', 'n']).then(function (res) { + assert.equal(res.error, null); + assert(Array.isArray(res.data)); + var expected = { + SourceFile: ctx.replaceSlashes(ctx.jpegFile), + Orientation: 6 + }; + assert.deepEqual(res.data[0], expected); + }); + }, + 'reads metadata of a file': function readsMetadataOfAFile(ctx) { + return ctx.initAndReadMetadata(ctx.jpegFile).then(function (res) { + assert.equal(res.error, null); + assert(Array.isArray(res.data)); + + var _res$data = _slicedToArray(res.data, 1), + metadata = _res$data[0]; + + var expected = { + SourceFile: ctx.replaceSlashes(ctx.jpegFile), + Directory: ctx.replaceSlashes(ctx.folder), + FileName: 'IMG_9858.JPG', + FileSize: '52 kB', + FileType: 'JPEG', + FileTypeExtension: 'jpg', + MIMEType: 'image/jpeg', + ExifByteOrder: 'Big-endian (Motorola, MM)', + Orientation: 'Rotate 90 CW', + XResolution: 72, + YResolution: 72, + ResolutionUnit: 'inches', + YCbCrPositioning: 'Centered', + XMPToolkit: 'Image::ExifTool 10.40', + CreatorWorkURL: 'https://sobesednik.media', + Scene: '011200', + Creator: 'Photographer Name', + ImageWidth: 500, + ImageHeight: 334, + EncodingProcess: 'Baseline DCT, Huffman coding', + BitsPerSample: 8, + ColorComponents: 3, + YCbCrSubSampling: 'YCbCr4:2:0 (2 2)', + ImageSize: '500x334', + Megapixels: 0.167 + }; + Object.keys(expected).forEach(function (key) { + return assert.equal(metadata[key], expected[key]); + }); + }); + }, + 'returns promise with null data and error when file not found': function returnsPromiseWithNullDataAndErrorWhenFileNotFound(ctx) { + return ctx.initAndReadMetadata(ctx.fileDoesNotExist).then(function (res) { + assert.equal(res.data, null); + assert.equal(res.error, 'File not found: ' + ctx.fileDoesNotExist); + }); + }, + 'works with simultaneous requests': function worksWithSimultaneousRequests(ctx) { + return ctx.createOpen().then(function () { + return Promise.all([ctx.ep.readMetadata(ctx.fileDoesNotExist), ctx.ep.readMetadata(ctx.fileDoesNotExist2), ctx.ep.readMetadata(ctx.jpegFile), ctx.ep.readMetadata(ctx.jpegFile2)]); + }).then(function (res) { + assert.equal(res[0].data, null); + assert.equal(res[0].error, 'File not found: ' + ctx.fileDoesNotExist); + + assert.equal(res[1].data, null); + assert.equal(res[1].error, 'File not found: ' + ctx.fileDoesNotExist2); + + assert(Array.isArray(res[2].data)); + assert.equal(res[2].error, null); + res[2].data.forEach(ctx.assertJpegMetadata); + + assert(Array.isArray(res[3].data)); + assert.equal(res[3].error, null); + res[3].data.forEach(ctx.assertJpegMetadata); + }); + } + }, + writeMetadata: { + 'returns rejected promise when trying to execute when not open': function returnsRejectedPromiseWhenTryingToExecuteWhenNotOpen(ctx) { + return ctx.create().writeMetadata('/temp-file', { comment: 'test-comment' }, ['overwrite_original']).then(function () { + throw new Error('writeMetadata should have resulted in error'); + }).catch(function (err) { + return assert.equal(err.message, 'exiftool is not open'); + }); + }, + 'should return rejected promise when data is not an object': function shouldReturnRejectedPromiseWhenDataIsNotAnObject(ctx) { + return ctx.initAndWriteMetadata('file_path').then(function () { + throw new Error('writeMetadata should have resulted in error'); + }, function (err) { + assert.equal(err.message, 'Data argument is not an object'); + }); + }, + 'should write metadata': function shouldWriteMetadata(ctx) { + var keywords = ['keywordA', 'keywordB']; + var comment = 'hello world'; + var data = { + all: '', + comment: comment, // has to come after all in order not to be removed + 'Keywords+': keywords + }; + return ctx.createTempFile().then(function () { + return ctx.initAndWriteMetadata(ctx.tempFile, data, ['overwrite_original']); + }).then(function (res) { + assert.equal(res.data, null); + assert.equal(res.error, '1 image files updated'); + }).then(function () { + return ctx.ep.readMetadata(ctx.tempFile); + }).then(function (res) { + assert(Array.isArray(res.data)); + assert.equal(res.error, null); + + var _res$data2 = _slicedToArray(res.data, 1), + metadata = _res$data2[0]; + + assert.equal(metadata.Keywords.length, keywords.length); + metadata.Keywords.forEach(function (keyword, index) { + assert.equal(keyword, keywords[index]); + }); + assert.equal(metadata.Comment, comment); + assert.equal(metadata.Scene, undefined); // should be removed with -all= + }); + } + } +}; + +module.exports = exiftoolTestSuite; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../test/spec/exiftool.js"],"names":["require","EOL","assert","child_process","context","exiftool","globalExiftoolConstructor","ExiftoolProcess","ChildProcess","exiftoolTestSuite","open","ctx","createOpen","then","pid","ep","_process","stdout","readable","stderr","stdin","writable","isOpen","equal","Error","err","message","create","eventPromise","Promise","on","events","OPEN","resolve","close","_stdoutResolveWs","_writableState","finished","_stderrResolveWs","p","readMetadata","jpegFile","res","Array","isArray","data","error","forEach","assertJpegMetadata","p2","jpegFile2","readPromises","all","Object","keys","_resolveMap","length","EXIT","catch","initAndReadMetadata","folder","emptyFolder","expected","SourceFile","replaceSlashes","Orientation","deepEqual","metadata","Directory","FileName","FileSize","FileType","FileTypeExtension","MIMEType","ExifByteOrder","XResolution","YResolution","ResolutionUnit","YCbCrPositioning","XMPToolkit","CreatorWorkURL","Scene","Creator","ImageWidth","ImageHeight","EncodingProcess","BitsPerSample","ColorComponents","YCbCrSubSampling","ImageSize","Megapixels","key","fileDoesNotExist","fileDoesNotExist2","writeMetadata","comment","initAndWriteMetadata","keywords","createTempFile","tempFile","Keywords","keyword","index","Comment","undefined","module","exports"],"mappings":"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","file":"exiftool.js","sourcesContent":["const { EOL } = require('os')\nconst assert = require('assert')\nconst child_process = require('child_process')\nconst context = require('exiftool-context')\nconst exiftool = require('../../src/')\ncontext.globalExiftoolConstructor = exiftool.ExiftoolProcess\n\nconst { ChildProcess } = child_process\n\nconst exiftoolTestSuite = {\n    context,\n    open: {\n        'opens exiftool': (ctx) => {\n            return ctx.createOpen()\n                .then((pid) => {\n                    assert(ctx.ep._process instanceof ChildProcess)\n                    assert(ctx.ep._process.stdout.readable)\n                    assert(ctx.ep._process.stderr.readable)\n                    assert(ctx.ep._process.stdin.writable)\n                    assert(ctx.ep.isOpen)\n                    assert.equal(typeof pid, 'number')\n                    assert.equal(pid, ctx.ep._process.pid)\n                })\n        },\n        'returns rejected promise when exiftool executable not found': (ctx) => {\n            return ctx.createOpen('notexiftool')\n                .then(() => {\n                    throw new Error('open should have resulted in error')\n                }, (err) => {\n                    assert.equal(err.message, 'spawn notexiftool ENOENT')\n                })\n        },\n        'emits OPEN event with PID': (ctx) => {\n            ctx.create()\n            const eventPromise = new Promise(resolve =>\n                ctx.ep.on(exiftool.events.OPEN, resolve)\n            )\n            return ctx.open()\n                .then(() => eventPromise)\n                .then(pid => assert.equal(pid, ctx.ep._process.pid))\n        },\n        'returns rejected promise when process is open already': (ctx) => {\n            return ctx.createOpen()\n                .then(() => ctx.open())\n                .then(() => {\n                    throw new Error('second open should have resulted in error')\n                }, (err) => {\n                    assert.equal(err.message, 'Exiftool process is already open')\n                })\n        },\n    },\n    close: {\n        'closes the process': (ctx) => {\n            return ctx.createOpen()\n                .then(() => ctx.close())\n                .then(() => {\n                    assert(ctx.ep._process instanceof ChildProcess)\n                    assert(!ctx.ep._process.stdout.readable)\n                    assert(!ctx.ep._process.stderr.readable)\n                    assert(!ctx.ep._process.stdin.writable)\n                    assert(!ctx.ep.isOpen)\n                })\n        },\n        'updates resolve write streams to be finished': (ctx) => {\n            return ctx.createOpen()\n                .then(() => ctx.close())\n                .then(() => {\n                    assert(ctx.ep._stdoutResolveWs._writableState.finished)\n                    assert(ctx.ep._stderrResolveWs._writableState.finished)\n                })\n        },\n        'completes remaining jobs': (ctx) => {\n            return ctx.createOpen()\n                .then(() => {\n                    const p = ctx.ep\n                        .readMetadata(ctx.jpegFile)\n                        .then((res) => {\n                            assert(Array.isArray(res.data))\n                            assert.equal(res.error, null)\n                            res.data.forEach(ctx.assertJpegMetadata)\n                        })\n                    const p2 = ctx.ep\n                        .readMetadata(ctx.jpegFile2)\n                        .then((res) => {\n                            assert(Array.isArray(res.data))\n                            assert.equal(res.error, null)\n                            res.data.forEach(ctx.assertJpegMetadata)\n                        })\n                    const readPromises = Promise.all([p, p2])\n\n                    return ctx.close()\n                        .then(() => {\n                            assert(!Object.keys(ctx.ep._stdoutResolveWs._resolveMap).length)\n                            assert(!Object.keys(ctx.ep._stderrResolveWs._resolveMap).length)\n                        })\n                        .then(() => readPromises)\n                })\n        },\n        'emits EXIT event': (ctx) => {\n            ctx.create()\n            const eventPromise = new Promise(resolve =>\n                ctx.ep.on(exiftool.events.EXIT, resolve)\n            )\n            return ctx.open()\n                .then(() => ctx.close())\n                .then(() => eventPromise)\n        },\n        'sets open to false': (ctx) => {\n            return ctx.createOpen()\n                .then(() => ctx.close())\n                .then(() => assert(!ctx.ep.isOpen))\n        },\n        'returns rejected promise when process not open': (ctx) => {\n            return ctx.create()\n                .close()\n                .then(() => {\n                    throw new Error('close should have resulted in error')\n                }, (err) => {\n                    assert.equal(err.message, 'Exiftool process is not open')\n                })\n        },\n    },\n    readMetadata: {\n        'returns rejected promise when trying to execute when not open': (ctx) => {\n            return ctx.create()\n                .readMetadata(ctx.jpegFile)\n                .then(() => {\n                    throw new Error('readMetadata should have resulted in error')\n                })\n                .catch(err => assert.equal(err.message, 'exiftool is not open'))\n        },\n        'reads metadata of files in a directory': (ctx) => {\n            return ctx.initAndReadMetadata(ctx.folder)\n                .then((res) => {\n                    assert(Array.isArray(res.data))\n                    assert.equal(res.data.length, 5)\n                    res.data.forEach(ctx.assertJpegMetadata)\n                    assert.equal(res.error, `1 directories scanned${EOL}    5 image files read`)\n                })\n        },\n        'returns null data for empty directory and info error': (ctx) => {\n            return ctx.initAndReadMetadata(ctx.emptyFolder)\n                .then((res) => {\n                    assert.equal(res.data, null)\n                    assert.equal(res.error, `1 directories scanned${EOL}    0 image files read`)\n                })\n        },\n        'allows to specify arguments': (ctx) => {\n            return ctx.initAndReadMetadata(ctx.jpegFile, ['Orientation', 'n'])\n                .then((res) => {\n                    assert.equal(res.error, null)\n                    assert(Array.isArray(res.data))\n                    const expected = {\n                        SourceFile: ctx.replaceSlashes(ctx.jpegFile),\n                        Orientation: 6,\n                    }\n                    assert.deepEqual(res.data[0], expected)\n                })\n        },\n        'reads metadata of a file': (ctx) => {\n            return ctx.initAndReadMetadata(ctx.jpegFile)\n                .then((res) => {\n                    assert.equal(res.error, null)\n                    assert(Array.isArray(res.data))\n                    const { data: [metadata] } = res\n                    const expected = {\n                        SourceFile: ctx.replaceSlashes(ctx.jpegFile),\n                        Directory: ctx.replaceSlashes(ctx.folder),\n                        FileName: 'IMG_9858.JPG',\n                        FileSize: '52 kB',\n                        FileType: 'JPEG',\n                        FileTypeExtension: 'jpg',\n                        MIMEType: 'image/jpeg',\n                        ExifByteOrder: 'Big-endian (Motorola, MM)',\n                        Orientation: 'Rotate 90 CW',\n                        XResolution: 72,\n                        YResolution: 72,\n                        ResolutionUnit: 'inches',\n                        YCbCrPositioning: 'Centered',\n                        XMPToolkit: 'Image::ExifTool 10.40',\n                        CreatorWorkURL: 'https://sobesednik.media',\n                        Scene: '011200',\n                        Creator: 'Photographer Name',\n                        ImageWidth: 500,\n                        ImageHeight: 334,\n                        EncodingProcess: 'Baseline DCT, Huffman coding',\n                        BitsPerSample: 8,\n                        ColorComponents: 3,\n                        YCbCrSubSampling: 'YCbCr4:2:0 (2 2)',\n                        ImageSize: '500x334',\n                        Megapixels: 0.167,\n                    }\n                    Object\n                        .keys(expected)\n                        .forEach(key =>\n                            assert.equal(metadata[key], expected[key])\n                        )\n                })\n        },\n        'returns promise with null data and error when file not found': (ctx) => {\n            return ctx.initAndReadMetadata(ctx.fileDoesNotExist)\n                .then((res) => {\n                    assert.equal(res.data, null)\n                    assert.equal(res.error, `File not found: ${ctx.fileDoesNotExist}`)\n                })\n        },\n        'works with simultaneous requests': (ctx) => {\n            return ctx.createOpen()\n                .then(() => Promise.all([\n                    ctx.ep.readMetadata(ctx.fileDoesNotExist),\n                    ctx.ep.readMetadata(ctx.fileDoesNotExist2),\n                    ctx.ep.readMetadata(ctx.jpegFile),\n                    ctx.ep.readMetadata(ctx.jpegFile2),\n                ]))\n                .then((res) => {\n                    assert.equal(res[0].data, null)\n                    assert.equal(res[0].error, `File not found: ${ctx.fileDoesNotExist}`)\n\n                    assert.equal(res[1].data, null)\n                    assert.equal(res[1].error, `File not found: ${ctx.fileDoesNotExist2}`)\n\n                    assert(Array.isArray(res[2].data))\n                    assert.equal(res[2].error, null)\n                    res[2].data.forEach(ctx.assertJpegMetadata)\n\n                    assert(Array.isArray(res[3].data))\n                    assert.equal(res[3].error, null)\n                    res[3].data.forEach(ctx.assertJpegMetadata)\n                })\n        },\n    },\n    writeMetadata: {\n        'returns rejected promise when trying to execute when not open': (ctx) => {\n            return ctx.create()\n                .writeMetadata('/temp-file', { comment: 'test-comment' }, ['overwrite_original'])\n                .then(() => {\n                    throw new Error('writeMetadata should have resulted in error')\n                })\n                .catch(err => assert.equal(err.message, 'exiftool is not open'))\n        },\n        'should return rejected promise when data is not an object': (ctx) => {\n            return ctx.initAndWriteMetadata('file_path')\n                .then(() => {\n                    throw new Error('writeMetadata should have resulted in error')\n                }, (err) => {\n                    assert.equal(err.message, 'Data argument is not an object')\n                })\n        },\n        'should write metadata': (ctx) => {\n            const keywords = [ 'keywordA', 'keywordB' ]\n            const comment = 'hello world'\n            const data = {\n                all: '',\n                comment, // has to come after all in order not to be removed\n                'Keywords+': keywords,\n            }\n            return ctx.createTempFile()\n                .then(() => ctx.initAndWriteMetadata(ctx.tempFile, data, ['overwrite_original']))\n                .then((res) => {\n                    assert.equal(res.data, null)\n                    assert.equal(res.error, '1 image files updated')\n                })\n                .then(() => ctx.ep.readMetadata(ctx.tempFile))\n                .then((res) => {\n                    assert(Array.isArray(res.data))\n                    assert.equal(res.error, null)\n                    const { data: [metadata] } = res\n                    assert.equal(metadata.Keywords.length, keywords.length)\n                    metadata.Keywords.forEach((keyword, index) => {\n                        assert.equal(keyword, keywords[index])\n                    })\n                    assert.equal(metadata.Comment, comment)\n                    assert.equal(metadata.Scene, undefined) // should be removed with -all=\n                })\n        },\n    },\n}\n\nmodule.exports = exiftoolTestSuite\n"]} \ No newline at end of file diff --git a/dist/test/spec/filename-encoding.js b/dist/test/spec/filename-encoding.js new file mode 100644 index 0000000..b9864d8 --- /dev/null +++ b/dist/test/spec/filename-encoding.js @@ -0,0 +1,39 @@ +'use strict'; + +require('source-map-support/register'); + +var assert = require('assert'); +var context = require('exiftool-context'); +var exiftool = require('../../src/'); +context.globalExiftoolConstructor = exiftool.ExiftoolProcess; + +/* +* If something is going wrong with this test suite, check +* https://github.com/Sobesednik/exiftool-context#filenamewithencoding +*/ +var Encoding = { + context: context, + /*'should contain correct file in the repo': (ctx) => { + const fs = require('fs') + const path = require('path') + const basename = path.basename(ctx.filenameWithEncoding) + const dir = path.dirname(ctx.filenameWithEncoding) + console.log('File to read: %s', ctx.filenameWithEncoding) + console.log('Filename in unicode to read: %s', ctx.toUnicode(basename)) + const res = fs.readdirSync(dir) + console.log('Files in fixtures:') + res.map(n => ` ${n}: ${ctx.toUnicode(n)}`).forEach(n => console.log(n)) + },*/ + 'should read file with filename in utf8': function shouldReadFileWithFilenameInUtf8(ctx) { + return ctx.initAndReadMetadata(ctx.filenameWithEncoding, ['charset filename=utf8']).then(function (res) { + assert.notEqual(res.data, null); + assert.equal(res.data[0].SourceFile, ctx.replaceSlashes(ctx.filenameWithEncoding)); + assert.equal(res.error, null); + }); + } +}; + +module.exports = { + encoding: Encoding +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Rlc3Qvc3BlYy9maWxlbmFtZS1lbmNvZGluZy5qcyJdLCJuYW1lcyI6WyJhc3NlcnQiLCJyZXF1aXJlIiwiY29udGV4dCIsImV4aWZ0b29sIiwiZ2xvYmFsRXhpZnRvb2xDb25zdHJ1Y3RvciIsIkV4aWZ0b29sUHJvY2VzcyIsIkVuY29kaW5nIiwiY3R4IiwiaW5pdEFuZFJlYWRNZXRhZGF0YSIsImZpbGVuYW1lV2l0aEVuY29kaW5nIiwidGhlbiIsInJlcyIsIm5vdEVxdWFsIiwiZGF0YSIsImVxdWFsIiwiU291cmNlRmlsZSIsInJlcGxhY2VTbGFzaGVzIiwiZXJyb3IiLCJtb2R1bGUiLCJleHBvcnRzIiwiZW5jb2RpbmciXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSxJQUFNQSxTQUFTQyxRQUFRLFFBQVIsQ0FBZjtBQUNBLElBQU1DLFVBQVVELFFBQVEsa0JBQVIsQ0FBaEI7QUFDQSxJQUFNRSxXQUFXRixRQUFRLFlBQVIsQ0FBakI7QUFDQUMsUUFBUUUseUJBQVIsR0FBb0NELFNBQVNFLGVBQTdDOztBQUVBOzs7O0FBSUEsSUFBTUMsV0FBVztBQUNiSixvQkFEYTtBQUViOzs7Ozs7Ozs7OztBQVlBLDhDQUEwQywwQ0FBQ0ssR0FBRCxFQUFTO0FBQy9DLGVBQU9BLElBQUlDLG1CQUFKLENBQXdCRCxJQUFJRSxvQkFBNUIsRUFBa0QsQ0FBQyx1QkFBRCxDQUFsRCxFQUNGQyxJQURFLENBQ0csVUFBQ0MsR0FBRCxFQUFTO0FBQ1hYLG1CQUFPWSxRQUFQLENBQWdCRCxJQUFJRSxJQUFwQixFQUEwQixJQUExQjtBQUNBYixtQkFBT2MsS0FBUCxDQUNJSCxJQUFJRSxJQUFKLENBQVMsQ0FBVCxFQUFZRSxVQURoQixFQUVJUixJQUFJUyxjQUFKLENBQW1CVCxJQUFJRSxvQkFBdkIsQ0FGSjtBQUlBVCxtQkFBT2MsS0FBUCxDQUFhSCxJQUFJTSxLQUFqQixFQUF3QixJQUF4QjtBQUNILFNBUkUsQ0FBUDtBQVNIO0FBeEJZLENBQWpCOztBQTJCQUMsT0FBT0MsT0FBUCxHQUFpQjtBQUNiQyxjQUFVZDtBQURHLENBQWpCIiwiZmlsZSI6ImZpbGVuYW1lLWVuY29kaW5nLmpzIiwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgYXNzZXJ0ID0gcmVxdWlyZSgnYXNzZXJ0JylcbmNvbnN0IGNvbnRleHQgPSByZXF1aXJlKCdleGlmdG9vbC1jb250ZXh0JylcbmNvbnN0IGV4aWZ0b29sID0gcmVxdWlyZSgnLi4vLi4vc3JjLycpXG5jb250ZXh0Lmdsb2JhbEV4aWZ0b29sQ29uc3RydWN0b3IgPSBleGlmdG9vbC5FeGlmdG9vbFByb2Nlc3NcblxuLypcbiogSWYgc29tZXRoaW5nIGlzIGdvaW5nIHdyb25nIHdpdGggdGhpcyB0ZXN0IHN1aXRlLCBjaGVja1xuKiBodHRwczovL2dpdGh1Yi5jb20vU29iZXNlZG5pay9leGlmdG9vbC1jb250ZXh0I2ZpbGVuYW1ld2l0aGVuY29kaW5nXG4qL1xuY29uc3QgRW5jb2RpbmcgPSB7XG4gICAgY29udGV4dCxcbiAgICAvKidzaG91bGQgY29udGFpbiBjb3JyZWN0IGZpbGUgaW4gdGhlIHJlcG8nOiAoY3R4KSA9PiB7XG4gICAgICAgIGNvbnN0IGZzID0gcmVxdWlyZSgnZnMnKVxuICAgICAgICBjb25zdCBwYXRoID0gcmVxdWlyZSgncGF0aCcpXG4gICAgICAgIGNvbnN0IGJhc2VuYW1lID0gcGF0aC5iYXNlbmFtZShjdHguZmlsZW5hbWVXaXRoRW5jb2RpbmcpXG4gICAgICAgIGNvbnN0IGRpciA9IHBhdGguZGlybmFtZShjdHguZmlsZW5hbWVXaXRoRW5jb2RpbmcpXG5cbiAgICAgICAgY29uc29sZS5sb2coJ0ZpbGUgdG8gcmVhZDogJXMnLCBjdHguZmlsZW5hbWVXaXRoRW5jb2RpbmcpXG4gICAgICAgIGNvbnNvbGUubG9nKCdGaWxlbmFtZSBpbiB1bmljb2RlIHRvIHJlYWQ6ICVzJywgY3R4LnRvVW5pY29kZShiYXNlbmFtZSkpXG4gICAgICAgIGNvbnN0IHJlcyA9IGZzLnJlYWRkaXJTeW5jKGRpcilcbiAgICAgICAgY29uc29sZS5sb2coJ0ZpbGVzIGluIGZpeHR1cmVzOicpXG4gICAgICAgIHJlcy5tYXAobiA9PiBgICR7bn06ICR7Y3R4LnRvVW5pY29kZShuKX1gKS5mb3JFYWNoKG4gPT4gY29uc29sZS5sb2cobikpXG4gICAgfSwqL1xuICAgICdzaG91bGQgcmVhZCBmaWxlIHdpdGggZmlsZW5hbWUgaW4gdXRmOCc6IChjdHgpID0+IHtcbiAgICAgICAgcmV0dXJuIGN0eC5pbml0QW5kUmVhZE1ldGFkYXRhKGN0eC5maWxlbmFtZVdpdGhFbmNvZGluZywgWydjaGFyc2V0IGZpbGVuYW1lPXV0ZjgnXSlcbiAgICAgICAgICAgIC50aGVuKChyZXMpID0+IHtcbiAgICAgICAgICAgICAgICBhc3NlcnQubm90RXF1YWwocmVzLmRhdGEsIG51bGwpXG4gICAgICAgICAgICAgICAgYXNzZXJ0LmVxdWFsKFxuICAgICAgICAgICAgICAgICAgICByZXMuZGF0YVswXS5Tb3VyY2VGaWxlLFxuICAgICAgICAgICAgICAgICAgICBjdHgucmVwbGFjZVNsYXNoZXMoY3R4LmZpbGVuYW1lV2l0aEVuY29kaW5nKVxuICAgICAgICAgICAgICAgIClcbiAgICAgICAgICAgICAgICBhc3NlcnQuZXF1YWwocmVzLmVycm9yLCBudWxsKVxuICAgICAgICAgICAgfSlcbiAgICB9LFxufVxuXG5tb2R1bGUuZXhwb3J0cyA9IHtcbiAgICBlbmNvZGluZzogRW5jb2RpbmcsXG59XG4iXX0= \ No newline at end of file diff --git a/dist/test/spec/handle-streams-finish.js b/dist/test/spec/handle-streams-finish.js new file mode 100644 index 0000000..555f205 --- /dev/null +++ b/dist/test/spec/handle-streams-finish.js @@ -0,0 +1,152 @@ +'use strict'; + +require('source-map-support/register'); + +function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } + +var context = require('exiftool-context'); +var assert = require('assert'); +var exiftool = require('../../src/'); +var killPid = require('../lib/kill-pid'); + +context.globalExiftoolConstructor = exiftool.ExiftoolProcess; + +// kill with operating system methods, rather than sending a signal, +// which does not work on Windows +function kill(proc) { + if (process.platform !== 'win32') { + return new Promise(function (resolve, reject) { + proc.once('error', reject); + proc.once('exit', resolve); + process.kill(proc.pid); + }); + } + return killPid(proc.pid); +} + +var expected = 'stdout and stderr finished before operation was complete'; + +var runTest = function () { + var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(ctx, getOperationPromise, createTempFile) { + var operationPromise, killPromise, message; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + ctx.create(); + + if (!createTempFile) { + _context.next = 4; + break; + } + + _context.next = 4; + return ctx.createTempFile(); + + case 4: + _context.next = 6; + return ctx.ep.open(); + + case 6: + // stdin might throw "read ECONNRESET" on Linux for some reason + ctx.ep._process.stdin.on('error', function () {}); + // patch stdout so that we never resolve read metadata promise + ctx.ep._stdoutResolveWs._write = function (obj, enc, next) { + next(); + }; + operationPromise = getOperationPromise(); + killPromise = kill(ctx.ep._process); + _context.prev = 10; + _context.next = 13; + return operationPromise; + + case 13: + throw new Error('Expected operation to be rejected'); + + case 16: + _context.prev = 16; + _context.t0 = _context['catch'](10); + message = _context.t0.message; + + assert.equal(message, expected); + _context.next = 22; + return killPromise; + + case 22: + case 'end': + return _context.stop(); + } + } + }, _callee, undefined, [[10, 16]]); + })); + + return function runTest(_x, _x2, _x3) { + return _ref.apply(this, arguments); + }; +}(); + +var closeStreamsOnExitTestSuite = { + context: context, + 'should return rejected promise when reading': function () { + var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(ctx) { + var getOperationPromise; + return regeneratorRuntime.wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + getOperationPromise = function getOperationPromise() { + return ctx.ep.readMetadata(ctx.folder); + }; + + _context2.next = 3; + return runTest(ctx, getOperationPromise); + + case 3: + case 'end': + return _context2.stop(); + } + } + }, _callee2, undefined); + })); + + return function shouldReturnRejectedPromiseWhenReading(_x4) { + return _ref3.apply(this, arguments); + }; + }(), + 'should return rejected promise when writing': function () { + var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(ctx) { + var getOperationPromise; + return regeneratorRuntime.wrap(function _callee3$(_context3) { + while (1) { + switch (_context3.prev = _context3.next) { + case 0: + getOperationPromise = function getOperationPromise() { + var keywords = ['keywordA', 'keywordB']; + var comment = 'hello world'; + var data = { + all: '', + comment: comment, // has to come after all in order not to be removed + 'Keywords+': keywords + }; + return ctx.ep.writeMetadata(ctx.tempFile, data, ['overwrite_original']); + }; + + _context3.next = 3; + return runTest(ctx, getOperationPromise, true); + + case 3: + case 'end': + return _context3.stop(); + } + } + }, _callee3, undefined); + })); + + return function shouldReturnRejectedPromiseWhenWriting(_x5) { + return _ref4.apply(this, arguments); + }; + }() +}; + +module.exports = closeStreamsOnExitTestSuite; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/test/spec/lib.js b/dist/test/spec/lib.js new file mode 100644 index 0000000..4d7414b --- /dev/null +++ b/dist/test/spec/lib.js @@ -0,0 +1,141 @@ +'use strict'; + +require('source-map-support/register'); + +var assert = require('assert'); + +var _require = require('os'), + EOL = _require.EOL; + +var lib = require('../../src/lib'); + +var libTestSuite = { + checkDataObject: { + 'should return true on object': function shouldReturnTrueOnObject() { + var data = { + comment: 'hello world' + }; + assert(lib.checkDataObject(data)); + }, + 'should return true on Object': function shouldReturnTrueOnObject() { + var data = new Object('foo'); + assert(lib.checkDataObject(data)); + }, + 'should return false on string': function shouldReturnFalseOnString() { + assert(!lib.checkDataObject('hello world')); + }, + 'should return false on boolean': function shouldReturnFalseOnBoolean() { + assert(!lib.checkDataObject(true)); + }, + 'should return false on array': function shouldReturnFalseOnArray() { + assert(!lib.checkDataObject(['hello world'])); + } + }, + mapDataToTagArray: { + 'should return an array with tags': function shouldReturnAnArrayWithTags() { + var data = { + tagA: 'valueA', + tagB: 'valueB' + }; + var res = lib.mapDataToTagArray(data); + assert.equal(res[0], 'tagA=valueA'); + assert.equal(res[1], 'tagB=valueB'); + }, + 'should return multiple entries when value is an array': function shouldReturnMultipleEntriesWhenValueIsAnArray() { + var data = { + 'tag+': ['valueA', 'valueB'] + }; + var res = lib.mapDataToTagArray(data); + assert.equal(res[0], 'tag+=valueA'); + assert.equal(res[1], 'tag+=valueB'); + }, + 'should push values to existing array': function shouldPushValuesToExistingArray() { + var array = ['json']; + var data = { + tagA: 'valueA', + tagB: 'valueB', + 'tagC+': ['valueC1', 'valueC2'] + + }; + lib.mapDataToTagArray(data, array); + assert.equal(array[0], 'json'); + assert.equal(array[1], 'tagA=valueA'); + assert.equal(array[2], 'tagB=valueB'); + assert.equal(array[3], 'tagC+=valueC1'); + assert.equal(array[4], 'tagC+=valueC2'); + } + }, + getArgs: { + 'should return empty array if argument is not array': function shouldReturnEmptyArrayIfArgumentIsNotArray() { + var res = lib.getArgs('non-array'); + assert.deepEqual(res, []); + }, + 'should return empty array if argument is empty array': function shouldReturnEmptyArrayIfArgumentIsEmptyArray() { + var res = lib.getArgs([]); + assert.deepEqual(res, []); + }, + 'should map args array to a string': function shouldMapArgsArrayToAString() { + var args = ['Creator', 'CreatorWorkURL', 'Orientation']; + var res = lib.getArgs(args); + var expected = ['-Creator', '-CreatorWorkURL', '-Orientation']; + assert.equal(res.length, expected.length); + res.forEach(function (arg, index) { + return assert.equal(arg, expected[index]); + }); + }, + 'should exclude non-strings': function shouldExcludeNonStrings() { + var args = ['Creator', 'CreatorWorkURL', 'Orientation', false, NaN, 1024]; + var res = lib.getArgs(args); + var expected = ['-Creator', '-CreatorWorkURL', '-Orientation']; + assert.equal(res.length, expected.length); + res.forEach(function (arg, index) { + return assert.equal(arg, expected[index]); + }); + }, + 'should split arguments': function shouldSplitArguments() { + var args = ['Creator', 'ext dng', 'o metadata.txt']; + var res = lib.getArgs(args); + var expected = ['-Creator', '-ext', 'dng', '-o', 'metadata.txt']; + assert.equal(res.length, expected.length); + res.forEach(function (arg, index) { + return assert.equal(arg, expected[index]); + }); + }, + 'should not split arguments with noSplit': function shouldNotSplitArgumentsWithNoSplit() { + var args = ['keywords+=keyword A', 'keywords+=keyword B', 'comment=hello world']; + var res = lib.getArgs(args, true); + var expected = ['-keywords+=keyword A', '-keywords+=keyword B', '-comment=hello world']; + assert.equal(res.length, expected.length); + res.forEach(function (arg, index) { + return assert.equal(arg, expected[index]); + }); + } + }, + execute: { + 'should write to process stdin': function shouldWriteToProcessStdin() { + var records = []; + var process = { + stdin: { + write: function write(record) { + return records.push(record); + } + } + }; + var command = 'file.jpg'; + var commandNumber = 1; + var args = ['Creator', 'ext dng', 'o metadata.txt', false, NaN]; + var noSplitArgs = ['comment=hello world']; + lib.execute(process, command, commandNumber, args, noSplitArgs); + var expected = ['-comment=hello world', '-Creator', '-ext', 'dng', '-o', 'metadata.txt', '-json', '-s', 'file.jpg', '-echo1', '{begin1}', '-echo2', '{begin1}', '-echo4', '{ready1}', '-execute1'].reduce(function (acc, arg) { + return [].concat(acc, [arg, EOL]); + }, []); + assert.equal(records.length, expected.length); + records.forEach(function (arg, index) { + return assert.equal(arg, expected[index]); + }); + } + } +}; + +module.exports = libTestSuite; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../test/spec/lib.js"],"names":["assert","require","EOL","lib","libTestSuite","checkDataObject","data","comment","Object","mapDataToTagArray","tagA","tagB","res","equal","array","getArgs","deepEqual","args","expected","length","forEach","arg","index","NaN","execute","records","process","stdin","write","push","record","command","commandNumber","noSplitArgs","reduce","acc","concat","module","exports"],"mappings":"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","file":"lib.js","sourcesContent":["const assert = require('assert')\nconst { EOL } = require('os')\nconst lib = require('../../src/lib')\n\nconst libTestSuite = {\n    checkDataObject: {\n        'should return true on object': () => {\n            const data = {\n                comment: 'hello world',\n            }\n            assert(lib.checkDataObject(data))\n        },\n        'should return true on Object': () => {\n            const data = new Object('foo')\n            assert(lib.checkDataObject(data))\n        },\n        'should return false on string': () => {\n            assert(!lib.checkDataObject('hello world'))\n        },\n        'should return false on boolean': () => {\n            assert(!lib.checkDataObject(true))\n        },\n        'should return false on array': () => {\n            assert(!lib.checkDataObject(['hello world']))\n        },\n    },\n    mapDataToTagArray: {\n        'should return an array with tags': () => {\n            const data = {\n                tagA: 'valueA',\n                tagB: 'valueB',\n            }\n            const res = lib.mapDataToTagArray(data)\n            assert.equal(res[0], 'tagA=valueA')\n            assert.equal(res[1], 'tagB=valueB')\n        },\n        'should return multiple entries when value is an array': () => {\n            const data = {\n                'tag+': [ 'valueA', 'valueB' ],\n            }\n            const res = lib.mapDataToTagArray(data)\n            assert.equal(res[0], 'tag+=valueA')\n            assert.equal(res[1], 'tag+=valueB')\n        },\n        'should push values to existing array': () => {\n            const array = [ 'json' ]\n            const data = {\n                tagA: 'valueA',\n                tagB: 'valueB',\n                'tagC+': [ 'valueC1', 'valueC2' ],\n\n            }\n            lib.mapDataToTagArray(data, array)\n            assert.equal(array[0], 'json')\n            assert.equal(array[1], 'tagA=valueA')\n            assert.equal(array[2], 'tagB=valueB')\n            assert.equal(array[3], 'tagC+=valueC1')\n            assert.equal(array[4], 'tagC+=valueC2')\n        },\n    },\n    getArgs: {\n        'should return empty array if argument is not array': () => {\n            const res = lib.getArgs('non-array')\n            assert.deepEqual(res, [])\n        },\n        'should return empty array if argument is empty array': () => {\n            const res = lib.getArgs([])\n            assert.deepEqual(res, [])\n        },\n        'should map args array to a string': () => {\n            const args = ['Creator', 'CreatorWorkURL', 'Orientation']\n            const res = lib.getArgs(args)\n            const expected = ['-Creator', '-CreatorWorkURL', '-Orientation']\n            assert.equal(res.length, expected.length)\n            res.forEach((arg, index) =>\n                assert.equal(arg, expected[index])\n            )\n        },\n        'should exclude non-strings': () => {\n            const args = ['Creator', 'CreatorWorkURL', 'Orientation', false, NaN, 1024]\n            const res = lib.getArgs(args)\n            const expected = ['-Creator', '-CreatorWorkURL', '-Orientation']\n            assert.equal(res.length, expected.length)\n            res.forEach((arg, index) =>\n                assert.equal(arg, expected[index])\n            )\n        },\n        'should split arguments': () => {\n            const args = ['Creator', 'ext dng', 'o  metadata.txt']\n            const res = lib.getArgs(args)\n            const expected = ['-Creator', '-ext', 'dng', '-o', 'metadata.txt']\n            assert.equal(res.length, expected.length)\n            res.forEach((arg, index) =>\n                assert.equal(arg, expected[index])\n            )\n        },\n        'should not split arguments with noSplit': () => {\n            const args = ['keywords+=keyword A', 'keywords+=keyword B', 'comment=hello world']\n            const res = lib.getArgs(args, true)\n            const expected = ['-keywords+=keyword A', '-keywords+=keyword B', '-comment=hello world']\n            assert.equal(res.length, expected.length)\n            res.forEach((arg, index) =>\n                assert.equal(arg, expected[index])\n            )\n        },\n    },\n    execute: {\n        'should write to process stdin': () => {\n            const records = []\n            const process = {\n                stdin: {\n                    write: record => records.push(record),\n                },\n            }\n            const command = 'file.jpg'\n            const commandNumber = 1\n            const args = [ 'Creator', 'ext dng', 'o  metadata.txt', false, NaN ]\n            const noSplitArgs = [ 'comment=hello world' ]\n            lib.execute(process, command, commandNumber, args, noSplitArgs)\n            const expected = [\n                '-comment=hello world',\n                '-Creator',\n                '-ext',\n                'dng',\n                '-o',\n                'metadata.txt',\n                '-json',\n                '-s',\n                'file.jpg',\n                '-echo1',\n                '{begin1}',\n                '-echo2',\n                '{begin1}',\n                '-echo4',\n                '{ready1}',\n                '-execute1',\n            ].reduce((acc, arg) => {\n                return [].concat(acc, [arg, EOL])\n            }, [])\n            assert.equal(records.length, expected.length)\n            records.forEach((arg, index) =>\n                assert.equal(arg, expected[index])\n            )\n        },\n    },\n}\n\nmodule.exports = libTestSuite\n"]} \ No newline at end of file diff --git a/dist/test/spec/options.js b/dist/test/spec/options.js new file mode 100644 index 0000000..b5b3268 --- /dev/null +++ b/dist/test/spec/options.js @@ -0,0 +1,53 @@ +'use strict'; + +require('source-map-support/register'); + +var context = require('exiftool-context'); +var assert = require('assert'); +var exiftool = require('../../src/'); +context.globalExiftoolConstructor = exiftool.ExiftoolProcess; + +var OptionsTestSuite = { + context: context, + 'calls child_process.spawn with specified options': function callsChild_processSpawnWithSpecifiedOptions(ctx) { + ctx.mockSpawn(); + var options = { detached: true }; + + return ctx.createOpen(options).then(function () { + assert.equal(ctx.proc.args.options, options); + }); + }, + 'returns rejected promise when trying to open without readable stderr': function returnsRejectedPromiseWhenTryingToOpenWithoutReadableStderr(ctx) { + var options = { + stdio: ['pipe', 'pipe', 'ignore'] + }; + return ctx.createOpen(options).then(function () { + throw new Error('open should have resulted in error'); + }, function (err) { + assert.equal(err.message, 'Process was not spawned with a readable stderr, check stdio options.'); + }); + }, + 'returns rejected promise when trying to open without readable stdout': function returnsRejectedPromiseWhenTryingToOpenWithoutReadableStdout(ctx) { + var options = { + stdio: ['ignore', 'ignore', 'pipe'] + }; + return ctx.createOpen(options).then(function () { + throw new Error('open should have resulted in error'); + }, function (err) { + assert.equal(err.message, 'Process was not spawned with a readable stdout, check stdio options.'); + }); + }, + 'returns rejected promise when trying to open without stdin': function returnsRejectedPromiseWhenTryingToOpenWithoutStdin(ctx) { + var options = { + stdio: ['ignore', 'pipe', 'pipe'] + }; + return ctx.createOpen(options).then(function () { + throw new Error('open should have resulted in error'); + }, function (err) { + assert.equal(err.message, 'Process was not spawned with a writable stdin, check stdio options.'); + }); + } +}; + +module.exports = OptionsTestSuite; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/test/spec/read-from-stream.js b/dist/test/spec/read-from-stream.js new file mode 100644 index 0000000..893277a --- /dev/null +++ b/dist/test/spec/read-from-stream.js @@ -0,0 +1,158 @@ +'use strict'; + +require('source-map-support/register'); + +var assert = require('assert'); +var context = require('exiftool-context'); +var fs = require('fs'); +var makepromise = require('makepromise'); +var exiftool = require('../../src/'); +var executeWithRs = require('../../src/execute-with-rs'); + +context.globalExiftoolConstructor = exiftool.ExiftoolProcess; + +var readFromStreamTestSuite = { + context: context, + 'should read metadata from a read stream': function shouldReadMetadataFromAReadStream(ctx) { + ctx.create(); + return ctx.ep.open().then(function () { + var rs = fs.createReadStream(ctx.jpegFile); + return ctx.ep.readMetadata(rs); + }).then(function (res) { + assert(Array.isArray(res.data)); + assert(res.data.length > 0); + return ctx.assertJpegMetadata(res.data[0]); + }); + } +}; + +function assertDoesNotExist(file) { + return makepromise(fs.stat, [file]).then(function () { + throw new Error('should have thrown ENOENT error'); + }, function (err) { + if (!/ENOENT/.test(err.message)) { + throw err; + } + }); +} +function assertExists(file) { + return makepromise(fs.stat, [file]).then(function () {}); +} + +var readFromRsTestSuite = { + context: context, + 'should reject if non-readable passed': function shouldRejectIfNonReadablePassed() { + return executeWithRs('string', null, function () {}).then(function () { + throw new Error('should have thrown an error'); + }, function (err) { + assert.equal(err.message, 'Please pass a readable stream'); + }); + }, + 'should reject if executeCommand is not a function': function shouldRejectIfExecuteCommandIsNotAFunction(ctx) { + var rs = fs.createReadStream(ctx.jpegFile); + return executeWithRs(rs).then(function () { + throw new Error('should have thrown an error'); + }, function (err) { + assert.equal(err.message, 'executeCommand must be a function'); + }); + }, + 'should read from a rs': function shouldReadFromARs(ctx) { + ctx.create(); + return ctx.ep.open().then(function () { + var rs = fs.createReadStream(ctx.jpegFile); + var executeCommand = ctx.ep._executeCommand.bind(ctx.ep); + return executeWithRs(rs, null, executeCommand); + }).then(function (res) { + assert(Array.isArray(res.data)); + assert(res.data.length > 0); + return ctx.assertJpegMetadata(res.data[0]); + }); + }, + 'should return execute function result': function shouldReturnExecuteFunctionResult(ctx) { + var rs = fs.createReadStream(ctx.jpegFile); + var result = [{ some: 'metadata' }, null]; + var executeCommand = function executeCommand() { + return result; + }; + return executeWithRs(rs, null, executeCommand).then(function (res) { + assert.strictEqual(res, result); + }); + }, + 'should call executeCommand with an existing file': function shouldCallExecuteCommandWithAnExistingFile(ctx) { + var rs = fs.createReadStream(ctx.jpegFile); + var tempFile = void 0; + var fileCreated = false; + var error = void 0; + var executeCommand = function executeCommand(_tempFile) { + tempFile = _tempFile; + return assertExists(tempFile).then(function () { + fileCreated = true; + }, function (_error) { + error = _error; + }); + }; + return executeWithRs(rs, null, executeCommand).then(function () { + assert(fileCreated); + assert.equal(error, undefined); + }); + }, + 'should call executeCommand with args': function shouldCallExecuteCommandWithArgs(ctx) { + var rs = fs.createReadStream(ctx.jpegFile); + var testArgs = ['some-arg=value']; + var args = void 0; + var executeCommand = function executeCommand(_, _args) { + args = _args; + }; + return executeWithRs(rs, testArgs, executeCommand).then(function () { + assert.strictEqual(args, testArgs); + }); + }, + 'should remove temp file': function shouldRemoveTempFile(ctx) { + var rs = fs.createReadStream(ctx.jpegFile); + var tempFile = void 0; + var executeCommand = function executeCommand(_tempFile) { + tempFile = _tempFile; + }; + return executeWithRs(rs, null, executeCommand).then(function () { + return assertDoesNotExist(tempFile); + }); + }, + 'should reject with execution error': function shouldRejectWithExecutionError(ctx) { + ctx.create(); + var error = new Error('error during execution'); + return ctx.ep.open().then(function () { + var rs = fs.createReadStream(ctx.jpegFile); + var executeCommand = function executeCommand() { + throw error; + }; + return executeWithRs(rs, null, executeCommand); + }).then(function () { + throw new Error('should have thrown execution error'); + }, function (err) { + assert.strictEqual(err, error); + }); + }, + 'should remove temp file if executeCommand failed': function shouldRemoveTempFileIfExecuteCommandFailed(ctx) { + ctx.create(); + var error = new Error('error during execution'); + var tempFile = void 0; + return ctx.ep.open().then(function () { + var rs = fs.createReadStream(ctx.jpegFile); + var executeCommand = function executeCommand(_tempFile) { + tempFile = _tempFile; + throw error; + }; + return executeWithRs(rs, null, executeCommand); + }).then(function () { + throw new Error('should have thrown execution error'); + }, function () { + return assertDoesNotExist(tempFile); + }); + } +}; + +module.exports = { + readFromStreamTestSuite: readFromStreamTestSuite, + readFromRsTestSuite: readFromRsTestSuite +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../test/spec/read-from-stream.js"],"names":["assert","require","context","fs","makepromise","exiftool","executeWithRs","globalExiftoolConstructor","ExiftoolProcess","readFromStreamTestSuite","ctx","create","ep","open","then","rs","createReadStream","jpegFile","readMetadata","res","Array","isArray","data","length","assertJpegMetadata","assertDoesNotExist","file","stat","Error","err","test","message","assertExists","readFromRsTestSuite","equal","executeCommand","_executeCommand","bind","result","some","strictEqual","tempFile","fileCreated","error","_tempFile","_error","undefined","testArgs","args","_","_args","module","exports"],"mappings":"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","file":"read-from-stream.js","sourcesContent":["const assert = require('assert')\nconst context = require('exiftool-context')\nconst fs = require('fs')\nconst makepromise = require('makepromise')\nconst exiftool = require('../../src/')\nconst executeWithRs = require('../../src/execute-with-rs')\n\ncontext.globalExiftoolConstructor = exiftool.ExiftoolProcess\n\nconst readFromStreamTestSuite = {\n    context,\n    'should read metadata from a read stream': (ctx) => {\n        ctx.create()\n        return ctx.ep.open()\n            .then(() => {\n                const rs = fs.createReadStream(ctx.jpegFile)\n                return ctx.ep.readMetadata(rs)\n            })\n            .then((res) => {\n                assert (Array.isArray(res.data))\n                assert(res.data.length > 0)\n                return ctx.assertJpegMetadata(res.data[0])\n            })\n    },\n}\n\nfunction assertDoesNotExist(file) {\n    return makepromise(fs.stat, [file])\n        .then(() => {\n            throw new Error('should have thrown ENOENT error')\n        }, (err) => {\n            if (!/ENOENT/.test(err.message)) {\n                throw err\n            }\n        })\n}\nfunction assertExists(file) {\n    return makepromise(fs.stat, [file])\n        .then(() => {})\n}\n\nconst readFromRsTestSuite = {\n    context,\n    'should reject if non-readable passed': () => {\n        return executeWithRs('string', null, () => {})\n            .then(() => {\n                throw new Error('should have thrown an error')\n            }, (err) => {\n                assert.equal(err.message, 'Please pass a readable stream')\n            })\n    },\n    'should reject if executeCommand is not a function': (ctx) => {\n        const rs = fs.createReadStream(ctx.jpegFile)\n        return executeWithRs(rs)\n            .then(() => {\n                throw new Error('should have thrown an error')\n            }, (err) => {\n                assert.equal(err.message, 'executeCommand must be a function')\n            })\n    },\n    'should read from a rs': (ctx) => {\n        ctx.create()\n        return ctx.ep.open()\n            .then(() => {\n                const rs = fs.createReadStream(ctx.jpegFile)\n                const executeCommand = ctx.ep._executeCommand.bind(ctx.ep)\n                return executeWithRs(rs, null, executeCommand)\n            })\n            .then((res) => {\n                assert (Array.isArray(res.data))\n                assert(res.data.length > 0)\n                return ctx.assertJpegMetadata(res.data[0])\n            })\n    },\n    'should return execute function result': (ctx) => {\n        const rs = fs.createReadStream(ctx.jpegFile)\n        const result = [{ some: 'metadata' }, null]\n        const executeCommand = () => {\n            return result\n        }\n        return executeWithRs(rs, null, executeCommand)\n            .then((res) => {\n                assert.strictEqual(res, result)\n            })\n    },\n    'should call executeCommand with an existing file': (ctx) => {\n        const rs = fs.createReadStream(ctx.jpegFile)\n        let tempFile\n        let fileCreated = false\n        let error\n        const executeCommand = (_tempFile) => {\n            tempFile = _tempFile\n            return assertExists(tempFile)\n                .then(() => {\n                    fileCreated = true\n                }, (_error) => {\n                    error = _error\n                })\n        }\n        return executeWithRs(rs, null, executeCommand)\n            .then(() => {\n                assert(fileCreated)\n                assert.equal(error, undefined)\n            })\n    },\n    'should call executeCommand with args': (ctx) => {\n        const rs = fs.createReadStream(ctx.jpegFile)\n        const testArgs = ['some-arg=value']\n        let args\n        const executeCommand = (_, _args) => {\n            args = _args\n        }\n        return executeWithRs(rs, testArgs, executeCommand)\n            .then(() => {\n                assert.strictEqual(args, testArgs)\n            })\n    },\n    'should remove temp file': (ctx) => {\n        const rs = fs.createReadStream(ctx.jpegFile)\n        let tempFile\n        const executeCommand = (_tempFile) => {\n            tempFile = _tempFile\n        }\n        return executeWithRs(rs, null, executeCommand)\n            .then(() => {\n                return assertDoesNotExist(tempFile)\n            })\n    },\n    'should reject with execution error': (ctx) => {\n        ctx.create()\n        const error = new Error('error during execution')\n        return ctx.ep.open()\n            .then(() => {\n                const rs = fs.createReadStream(ctx.jpegFile)\n                const executeCommand = () => {\n                    throw error\n                }\n                return executeWithRs(rs, null, executeCommand)\n            })\n            .then(() => {\n                throw new Error('should have thrown execution error')\n            }, (err) => {\n                assert.strictEqual(err, error)\n            })\n    },\n    'should remove temp file if executeCommand failed': (ctx) => {\n        ctx.create()\n        const error = new Error('error during execution')\n        let tempFile\n        return ctx.ep.open()\n            .then(() => {\n                const rs = fs.createReadStream(ctx.jpegFile)\n                const executeCommand = (_tempFile) => {\n                    tempFile = _tempFile\n                    throw error\n                }\n                return executeWithRs(rs, null, executeCommand)\n            })\n            .then(() => {\n                throw new Error('should have thrown execution error')\n            }, () => {\n                return assertDoesNotExist(tempFile)\n            })\n    },\n}\n\nmodule.exports = {\n    readFromStreamTestSuite,\n    readFromRsTestSuite,\n}\n"]} \ No newline at end of file diff --git a/examples/.eslintrc b/examples/.eslintrc index a85fe17..4fe6cc5 100644 --- a/examples/.eslintrc +++ b/examples/.eslintrc @@ -1,5 +1,6 @@ { "rules": { - "no-console": "off" + "no-console": "off", + "prefer-destructuring": "off" } } diff --git a/package.json b/package.json index bf8b8f9..4b47351 100644 --- a/package.json +++ b/package.json @@ -2,16 +2,23 @@ "name": "node-exiftool", "version": "2.3.0", "description": "A Node.js interface to exiftool command-line application.", - "main": "src/index.js", + "main": "dist/src/index.js", "files": [ + "dist/", "src/" ], "scripts": { "test": "cross-env ZOROASTER_TIMEOUT=10000 zoroaster test/spec", + "test-build": "cross-env ZOROASTER_TIMEOUT=10000 zoroaster dist/test/spec", "test-watch": "zoroaster test/spec --watch", "bench": "node benchmark/run", + "build-src": "babel src --out-dir dist/src", + "build-test": "babel test --out-dir dist/test", + "build": "run-s build-src build-test", + "build-and-test": "run-s build test-build", "callback-example": "LOCAL=1 node examples/callback examples/28.jpg", - "write-example": "node examples/write_metadata/index" + "write-example": "node examples/write_metadata/index", + "lint": "eslint ." }, "repository": { "type": "git", @@ -30,15 +37,23 @@ }, "homepage": "https://github.com/Sobesednik/node-exiftool#readme", "devDependencies": { + "babel-cli": "6.26.0", + "babel-plugin-source-map-support": "1.0.0", + "babel-plugin-transform-async-to-generator": "6.24.1", + "babel-preset-es2015": "6.24.1", "cross-env": "5.0.0", + "eslint": "4.9.0", "exiftool-context": "1.4.0", "makepromise": "1.0.0", + "npm-run-all": "4.1.1", "ps-node": "0.1.6", "zoroaster": "0.4.6" }, "dependencies": { + "erotic": "0.1.0", "is-stream": "1.1.0", "restream": "1.2.0", + "source-map-support": "0.5.0", "wrote": "0.6.1" } } diff --git a/src/begin-ready.js b/src/begin-ready.js index fd3e420..b36f02e 100644 --- a/src/begin-ready.js +++ b/src/begin-ready.js @@ -1,7 +1,4 @@ -'use strict' - -const Transform = require('stream').Transform -const Writable = require('stream').Writable +const { Transform, Writable } = require('stream') const restream = require('restream') const BEGIN_READY_RE = /{begin(\d+)}([\s\S]*){ready\1}/g diff --git a/src/execute-with-rs.js b/src/execute-with-rs.js index 5d283b4..f409ee7 100644 --- a/src/execute-with-rs.js +++ b/src/execute-with-rs.js @@ -1,10 +1,9 @@ -'use strict' const wrote = require('wrote') -const Readable = require('stream').Readable +const { Readable } = require('stream') /** * Create temp file for rs, execute exiftool command, then erase file - * @param {Readable} rs a read strem + * @param {Readable} rs a read stream * @param {string[]} args Arguments * @param {function} executeCommand function which is responsible for executing the command */ diff --git a/src/index.js b/src/index.js index 48471b0..0edda02 100644 --- a/src/index.js +++ b/src/index.js @@ -1,5 +1,3 @@ -'use strict' - const EventEmitter = require('events') const lib = require('./lib') const beginReady = require('./begin-ready') @@ -55,7 +53,7 @@ class ExiftoolProcess extends EventEmitter { * @returns {Promise.} A promise to spawn exiftool in stay_open * mode, resolved with pid. */ - open(encoding, options) { + async open(encoding, options) { let _encoding = encoding let _options = options // if encoding is not a string and options are not given, treat it as options @@ -65,45 +63,43 @@ class ExiftoolProcess extends EventEmitter { } this._assignEncoding(_encoding) if (this._open) { - return Promise.reject(new Error('Exiftool process is already open')) + throw new Error('Exiftool process is already open') + } + const exiftoolProcess = await lib.spawn(this._bin, _options) + //console.log(`Started exiftool process %s`, process.pid); + this.emit(events.OPEN, exiftoolProcess.pid) + this._process = exiftoolProcess + + this._process.on('exit', this._exitListener.bind(this)) + if (!lib.isReadable(this._process.stdout)) { + lib.killProcess(this._process) + throw new Error('Process was not spawned with a readable stdout, check stdio options.') + } + if (!lib.isWritable(this._process.stdin)) { + lib.killProcess(this._process) + throw new Error('Process was not spawned with a writable stdin, check stdio options.') } - return lib.spawn(this._bin, _options) - .then((exiftoolProcess) => { - //console.log(`Started exiftool process %s`, process.pid); - this.emit(events.OPEN, exiftoolProcess.pid) - this._process = exiftoolProcess - - this._process.on('exit', this._exitListener.bind(this)) - if (!lib.isReadable(this._process.stdout)) { - lib.killProcess(this._process) - throw new Error('Process was not spawned with a readable stdout, check stdio options.') - } - if (!lib.isWritable(this._process.stdin)) { - lib.killProcess(this._process) - throw new Error('Process was not spawned with a writable stdin, check stdio options.') - } - - // if process was spawned, stderr is readable (see lib/spawn) - - this._process.stdout.setEncoding(this._encoding) - this._process.stderr.setEncoding(this._encoding) - - // resolve-write streams - this._stdoutResolveWs = beginReady.setupResolveWriteStreamPipe(this._process.stdout) - this._stderrResolveWs = beginReady.setupResolveWriteStreamPipe(this._process.stderr) - - // handle errors so that Node does not crash - this._stdoutResolveWs.on('error', console.error) // eslint-disable-line no-console - this._stderrResolveWs.on('error', console.error) // eslint-disable-line no-console - - // debug - // exiftoolProcess.stdout.pipe(process.stdout) - // exiftoolProcess.stderr.pipe(process.stderr) - - this._open = true - - return exiftoolProcess.pid - }) + + // if process was spawned, stderr is readable (see lib/spawn) + + this._process.stdout.setEncoding(this._encoding) + this._process.stderr.setEncoding(this._encoding) + + // resolve-write streams + this._stdoutResolveWs = beginReady.setupResolveWriteStreamPipe(this._process.stdout) + this._stderrResolveWs = beginReady.setupResolveWriteStreamPipe(this._process.stderr) + + // handle errors so that Node does not crash + this._stdoutResolveWs.on('error', console.error) // eslint-disable-line no-console + this._stderrResolveWs.on('error', console.error) // eslint-disable-line no-console + + // debug + // exiftoolProcess.stdout.pipe(process.stdout) + // exiftoolProcess.stderr.pipe(process.stderr) + + this._open = true + + return exiftoolProcess.pid } _exitListener() { @@ -120,13 +116,13 @@ class ExiftoolProcess extends EventEmitter { return this._open } - _executeCommand(command, args, argsNoSplit, debug) { + async _executeCommand(command, args, argsNoSplit, debug) { //test this! if (!this._open) { - return Promise.reject(new Error('exiftool is not open')) + throw new Error('exiftool is not open') } if (this._process.signalCode === 'SIGTERM') { - return Promise.reject(new Error('Could not connect to the exiftool process')) + throw new Error('Could not connect to the exiftool process') } const proc = debug === true ? process : this._process @@ -159,12 +155,12 @@ class ExiftoolProcess extends EventEmitter { * @returns {Promise.<{{data, error}}>} A promise to write metadata, * resolved with data from stdout and stderr. */ - writeMetadata(file, data, args, debug) { + async writeMetadata(file, data, args, debug) { if (!lib.isString(file)) { throw new Error('File must be a string') } if (!lib.checkDataObject(data)) { - return Promise.reject(new Error('Data argument is not an object')) + throw new Error('Data argument is not an object') } const writeArgs = lib.mapDataToTagArray(data) diff --git a/src/lib.js b/src/lib.js index f21c113..3e7aee4 100644 --- a/src/lib.js +++ b/src/lib.js @@ -1,8 +1,7 @@ -'use strict' - const cp = require('child_process') -const EOL = require('os').EOL +const { EOL } = require('os') const isStream = require('is-stream') +const erotic = require('erotic') function writeStdIn(proc, data, encoding) { // console.log('write stdin', data) @@ -11,17 +10,18 @@ function writeStdIn(proc, data, encoding) { } function close(proc) { + const er = erotic() let errHandler return new Promise((resolve, reject) => { - errHandler = (err) => { - reject(new Error(`Could not write to stdin: ${err.message}`)) + errHandler = ({ message }) => { + const err = er(message) + reject(err) } proc.once('close', resolve) proc.stdin.once('error', errHandler) writeStdIn(proc, '-stay_open') writeStdIn(proc, 'false') - }) - .then(() => { + }).then(() => { proc.stdin.removeListener('error', errHandler) }) } @@ -46,7 +46,7 @@ function getArgs(args, noSplit) { .map(arg => `-${arg}`) .reduce((acc, arg) => [].concat(acc, noSplit ? [arg] : arg.split(/\s+/)) - , []) + , []) } /** @@ -80,6 +80,7 @@ function execute(proc, command, commandNumber, args, noSplitArgs, encoding) { ] ) if (process.env.DEBUG) { + // eslint-disable-next-line no-console console.log(JSON.stringify(allArgs, null, 2)) } allArgs.forEach(arg => writeStdIn(proc, arg, encoding)) diff --git a/test/fixtures/detached.js b/test/fixtures/detached.js index 37453c5..459d423 100644 --- a/test/fixtures/detached.js +++ b/test/fixtures/detached.js @@ -1,21 +1,21 @@ -const ExiftoolContext = require('exiftool-context') -const exiftool = require('../../.') - -const bin = ExiftoolContext.exiftoolBin -const ep = new exiftool.ExiftoolProcess(bin) +const { exiftoolBin: bin } = require('exiftool-context') +const exiftool = require('../../src/') if (typeof process.send !== 'function') { throw new Error('This module should be spawned with an IPC channel.') } -const EXIFTOOL_DETACHED = process.env.EXIFTOOL_DETACHED === 'true' +const { EXIFTOOL_DETACHED } = process.env + +const detached = EXIFTOOL_DETACHED === 'true'; -ep - .open({ detached: EXIFTOOL_DETACHED }) - .then((pid) => { +(async () => { + try { + const ep = new exiftool.ExiftoolProcess(bin) + const pid = await ep.open({ detached }) process.send(pid) - }) - .catch((err) => { + } catch (err) { console.log(err) // eslint-disable-line no-console process.exit(1) - }) + } +})() diff --git a/test/spec/begin-ready.js b/test/spec/begin-ready.js index ce1e376..1a0fb4b 100644 --- a/test/spec/begin-ready.js +++ b/test/spec/begin-ready.js @@ -1,11 +1,10 @@ const assert = require('assert') -const Readable = require('stream').Readable -const Writable = require('stream').Writable -const Transform = require('stream').Transform -const beginReady = require('../../src/begin-ready') -const createBeginReadyMatchTransformStream = beginReady.createBeginReadyMatchTransformStream -const createResolverWriteStream = beginReady.createResolverWriteStream -const setupResolveWriteStreamPipe = beginReady.setupResolveWriteStreamPipe +const { Readable, Writable } = require('stream') +const { + createBeginReadyMatchTransformStream, + createResolverWriteStream, + setupResolveWriteStreamPipe, +} = require('../../src/begin-ready') /** * Pipe Readable stream in object mode into process.stdout, @@ -14,16 +13,16 @@ const setupResolveWriteStreamPipe = beginReady.setupResolveWriteStreamPipe * gets assigned a lot of stream listeners such as end, drain, * error, finish, unpipe, close. */ -function debugObjectReadStream(rs, name) { - rs.pipe(new Transform({ - objectMode: true, - transform: (chunk, enc, next) => { - const s = JSON.stringify(chunk, null, 2) - console.log(`Some data from ${name} rs: `) - next(null, `${s}\r\n`) - }, - })).pipe(process.stdout) -} +// function debugObjectReadStream(rs, name) { +// rs.pipe(new Transform({ +// objectMode: true, +// transform: (chunk, enc, next) => { +// const s = JSON.stringify(chunk, null, 2) +// console.log(`Some data from ${name} rs: `) +// next(null, `${s}\r\n`) +// }, +// })).pipe(process.stdout) +// } const commandNumber = '376080' const commandNumber2 = '65754' @@ -111,8 +110,7 @@ const brtsTestSuite = { }) .then((res) => { assert.equal(res.length, 2) - const output = res[0] - const output2 = res[1] + const [output, output2] = res assert.equal(output.cn, commandNumber) assert.equal(output.d, data) assert.equal(output2.cn, commandNumber2) diff --git a/test/spec/codedcharacterset.js b/test/spec/codedcharacterset.js index c0fbbd1..741a90c 100644 --- a/test/spec/codedcharacterset.js +++ b/test/spec/codedcharacterset.js @@ -1,5 +1,5 @@ const assert = require('assert') -const EOL = require('os').EOL +const { EOL } = require('os') const context = require('exiftool-context') const exiftool = require('../../src/') context.globalExiftoolConstructor = exiftool.ExiftoolProcess diff --git a/test/spec/detached-true.js b/test/spec/detached-true.js index 7df45ee..cd3d1db 100644 --- a/test/spec/detached-true.js +++ b/test/spec/detached-true.js @@ -1,5 +1,3 @@ -'use strict' - const makepromise = require('makepromise') const ps = require('ps-node') const assert = require('assert') @@ -86,11 +84,11 @@ const findExiftoolChildAndConhost = (epPid, exiftoolDetached) => { if (!exiftoolDetached) return res // if detached, conhost is child of child exiftool, // which we are now finding - const childExiftool = res[0] + const [childExiftool] = res assert(childExiftool) assert(/exiftool\.exe/.test(childExiftool.command)) return checkPpid(childExiftool.pid).then((conhostRes) => { - const conhost = conhostRes[0] + const [conhost] = conhostRes assert(conhost) assert(/conhost.exe/.test(conhost.command)) const all = [].concat(conhostRes, res) @@ -119,10 +117,7 @@ const setup = (exiftoolDetached, ctx) => { let checkPids return ctx.forkNode(exiftoolDetached) - .then((meta) => { - const forkPid = meta.forkPid - const epPid = meta.epPid - + .then(({ forkPid, epPid }) => { const res = { forkPid, epPid } if (isWindows) { diff --git a/test/spec/exiftool.js b/test/spec/exiftool.js index 292bbae..0154b48 100644 --- a/test/spec/exiftool.js +++ b/test/spec/exiftool.js @@ -1,12 +1,11 @@ -const os = require('os') +const { EOL } = require('os') const assert = require('assert') const child_process = require('child_process') const context = require('exiftool-context') const exiftool = require('../../src/') context.globalExiftoolConstructor = exiftool.ExiftoolProcess -const ChildProcess = child_process.ChildProcess -const EOL = os.EOL +const { ChildProcess } = child_process const exiftoolTestSuite = { context, @@ -163,7 +162,7 @@ const exiftoolTestSuite = { .then((res) => { assert.equal(res.error, null) assert(Array.isArray(res.data)) - const metadata = res.data[0] + const { data: [metadata] } = res const expected = { SourceFile: ctx.replaceSlashes(ctx.jpegFile), Directory: ctx.replaceSlashes(ctx.folder), @@ -265,13 +264,13 @@ const exiftoolTestSuite = { .then((res) => { assert(Array.isArray(res.data)) assert.equal(res.error, null) - const meta = res.data[0] - assert.equal(meta.Keywords.length, keywords.length) - meta.Keywords.forEach((keyword, index) => { + const { data: [metadata] } = res + assert.equal(metadata.Keywords.length, keywords.length) + metadata.Keywords.forEach((keyword, index) => { assert.equal(keyword, keywords[index]) }) - assert.equal(meta.Comment, comment) - assert.equal(meta.Scene, undefined) // should be removed with -all= + assert.equal(metadata.Comment, comment) + assert.equal(metadata.Scene, undefined) // should be removed with -all= }) }, }, diff --git a/test/spec/handle-streams-finish.js b/test/spec/handle-streams-finish.js index f0d7d09..7b7f46d 100644 --- a/test/spec/handle-streams-finish.js +++ b/test/spec/handle-streams-finish.js @@ -1,5 +1,3 @@ -'use strict' - const context = require('exiftool-context') const assert = require('assert') const exiftool = require('../../src/') @@ -9,51 +7,49 @@ context.globalExiftoolConstructor = exiftool.ExiftoolProcess // kill with operating system methods, rather than sending a signal, // which does not work on Windows -function killAndWaitForExit(proc) { - const pid = proc.pid - const killPromise = killPid(pid) - const exitPromise = new Promise(resolve => proc.once('exit', resolve)) - return Promise.all([killPromise, exitPromise]) +function kill(proc) { + if (process.platform !== 'win32') { + return new Promise((resolve, reject) => { + proc.once('error', reject) + proc.once('exit', resolve) + process.kill(proc.pid) + }) + } + return killPid(proc.pid) } const expected = 'stdout and stderr finished before operation was complete' -const runTest = (ctx, getOperationPromise, createTempFile) => { - let err +const runTest = async (ctx, getOperationPromise, createTempFile) => { ctx.create() - return (createTempFile ? ctx.createTempFile() : Promise.resolve()) - .then(() => ctx.ep.open()) - .then(() => { - // stdin might throw "read ECONNRESET" on Linux for some reason - ctx.ep._process.stdin.on('error', () => {}) - // patch stdout so that we never resolve read metadata promise - ctx.ep._stdoutResolveWs._write = (obj, enc, next) => { - next() - } - const operationPromise = getOperationPromise() - .catch((error) => { err = error }) + if (createTempFile) await ctx.createTempFile() + await ctx.ep.open() + // stdin might throw "read ECONNRESET" on Linux for some reason + ctx.ep._process.stdin.on('error', () => {}) + // patch stdout so that we never resolve read metadata promise + ctx.ep._stdoutResolveWs._write = (obj, enc, next) => { + next() + } + const operationPromise = getOperationPromise() - const killPromise = killAndWaitForExit(ctx.ep._process) + const killPromise = kill(ctx.ep._process) - return Promise.all([operationPromise, killPromise]) - }) - .then(() => { - if (!err) { - throw new Error('Expected operation to be rejected') - } - throw err - }).catch((error) => { - assert.equal(error.message, expected) - }) + try { + await operationPromise + throw new Error('Expected operation to be rejected') + } catch ({ message }) { + assert.equal(message, expected) + await killPromise + } } const closeStreamsOnExitTestSuite = { context, - 'should return rejected promise on read': (ctx) => { + 'should return rejected promise when reading': async (ctx) => { const getOperationPromise = () => ctx.ep.readMetadata(ctx.folder) - return runTest(ctx, getOperationPromise) + await runTest(ctx, getOperationPromise) }, - 'should return rejected promise on write': (ctx) => { + 'should return rejected promise when writing': async (ctx) => { const getOperationPromise = () => { const keywords = [ 'keywordA', 'keywordB' ] const comment = 'hello world' @@ -65,7 +61,7 @@ const closeStreamsOnExitTestSuite = { return ctx.ep.writeMetadata(ctx.tempFile, data, ['overwrite_original']) } - return runTest(ctx, getOperationPromise, true) + await runTest(ctx, getOperationPromise, true) }, } diff --git a/test/spec/lib.js b/test/spec/lib.js index b07f103..22a1039 100644 --- a/test/spec/lib.js +++ b/test/spec/lib.js @@ -1,5 +1,5 @@ const assert = require('assert') -const EOL = require('os').EOL +const { EOL } = require('os') const lib = require('../../src/lib') const libTestSuite = { diff --git a/test/spec/read-from-stream.js b/test/spec/read-from-stream.js index 171e30c..89fdaaa 100644 --- a/test/spec/read-from-stream.js +++ b/test/spec/read-from-stream.js @@ -1,4 +1,3 @@ -'use strict' const assert = require('assert') const context = require('exiftool-context') const fs = require('fs')