diff --git a/.babelrc b/.babelrc new file mode 100644 index 0000000..8c6c245 --- /dev/null +++ b/.babelrc @@ -0,0 +1,6 @@ +{ + "plugins": [ + "transform-flow-strip-types" + ], + "presets": ["es2015"] +} diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..5ebc552 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,16 @@ +# EditorConfig is awesome: http://EditorConfig.org + +root = true; + +[*] +# Ensure there's no lingering whitespace +trim_trailing_whitespace = true +# Ensure a newline at the end of each file +insert_final_newline = true + +[*.js] +# Unix-style newlines +end_of_line = lf +charset = utf-8 +indent_style = space +indent_size = 2 diff --git a/.eslintrc b/.eslintrc new file mode 100644 index 0000000..6a5e68d --- /dev/null +++ b/.eslintrc @@ -0,0 +1,146 @@ +{ + "parser": "babel-eslint", + "plugins": [ + "flow-vars" + ], + "rules": { + "comma-dangle": 2, // disallow or enforce trailing commas + "no-cond-assign": 2, // disallow assignment in conditional expressions + "no-console": 1, // disallow use of console (off by default in the node environment) + "no-constant-condition": 2, // disallow use of constant expressions in conditions + "no-control-regex": 2, // disallow control characters in regular expressions + "no-debugger": 2, // disallow use of debugger + "no-dupe-args": 2, // disallow duplicate arguments in functions + "no-dupe-keys": 2, // disallow duplicate keys when creating object literals + "no-duplicate-case": 2, // disallow a duplicate case label. + "no-empty": 2, // disallow empty statements + "no-ex-assign": 2, // disallow assigning to the exception in a catch block + "no-extra-boolean-cast": 2, // disallow double-negation boolean casts in a boolean context + "no-extra-parens": 0, // disallow unnecessary parentheses (off by default) + "no-extra-semi": 2, // disallow unnecessary semicolons + "no-func-assign": 2, // disallow overwriting functions written as function declarations + "no-inner-declarations": 2, // disallow function or variable declarations in nested blocks + "no-invalid-regexp": 2, // disallow invalid regular expression strings in the RegExp constructor + "no-irregular-whitespace": 2, // disallow irregular whitespace outside of strings and comments + "no-negated-in-lhs": 2, // disallow negation of the left operand of an in expression + "no-obj-calls": 2, // disallow the use of object properties of the global object (Math and JSON) as functions + "no-regex-spaces": 2, // disallow multiple spaces in a regular expression literal + "no-sparse-arrays": 2, // disallow sparse arrays + "no-unreachable": 2, // disallow unreachable statements after a return, throw, continue, or break statement + "use-isnan": 2, // disallow comparisons with the value NaN + "valid-jsdoc": 2, // Ensure JSDoc comments are valid (off by default) + "valid-typeof": 2, // Ensure that the results of typeof are compared against a valid string + "block-scoped-var": 0, // treat var statements as if they were block scoped (off by default). 0: deep destructuring is not compatible https://github.com/eslint/eslint/issues/1863 + "complexity": 0, // specify the maximum cyclomatic complexity allowed in a program (off by default) + "consistent-return": 0, // require return statements to either always or never specify values + "curly": 2, // specify curly brace conventions for all control statements + "default-case": 2, // require default case in switch statements (off by default) + "dot-notation": 2, // encourages use of dot notation whenever possible + "eqeqeq": 2, // require the use of === and !== + "guard-for-in": 2, // make sure for-in loops have an if statement (off by default) + "no-alert": 2, // disallow the use of alert, confirm, and prompt + "no-caller": 2, // disallow use of arguments.caller or arguments.callee + "no-div-regex": 2, // disallow division operators explicitly at beginning of regular expression (off by default) + "no-else-return": 2, // disallow else after a return in an if (off by default) + "no-eq-null": 2, // disallow comparisons to null without a type-checking operator (off by default) + "no-eval": 2, // disallow use of eval() + "no-extend-native": 2, // disallow adding to native types + "no-extra-bind": 2, // disallow unnecessary function binding + "no-fallthrough": 2, // disallow fallthrough of case statements + "no-floating-decimal": 2, // disallow the use of leading or trailing decimal points in numeric literals (off by default) + "no-implied-eval": 2, // disallow use of eval()-like methods + "no-iterator": 2, // disallow usage of __iterator__ property + "no-labels": 2, // disallow use of labeled statements + "no-lone-blocks": 2, // disallow unnecessary nested blocks + "no-loop-func": 2, // disallow creation of functions within loops + "no-multi-spaces": 2, // disallow use of multiple spaces + "no-multi-str": 2, // disallow use of multiline strings + "no-native-reassign": 2, // disallow reassignments of native objects + "no-new": 2, // disallow use of new operator when not part of the assignment or comparison + "no-new-func": 2, // disallow use of new operator for Function object + "no-new-wrappers": 2, // disallows creating new instances of String,Number, and Boolean + "no-octal": 2, // disallow use of octal literals + "no-octal-escape": 2, // disallow use of octal escape sequences in string literals, such as var foo = "Copyright \251"; + "no-param-reassign": 0, // disallow reassignment of function parameters (off by default) + "no-process-env": 2, // disallow use of process.env (off by default) + "no-proto": 2, // disallow usage of __proto__ property + "no-redeclare": 2, // disallow declaring the same variable more then once + "no-return-assign": 2, // disallow use of assignment in return statement + "no-script-url": 2, // disallow use of javascript: urls. + "no-self-compare": 2, // disallow comparisons where both sides are exactly the same (off by default) + "no-sequences": 2, // disallow use of comma operator + "no-throw-literal": 2, // restrict what can be thrown as an exception (off by default) + "no-unused-expressions": 2, // disallow usage of expressions in statement position + "no-void": 2, // disallow use of void operator (off by default) + "no-warning-comments": [0, {"terms": ["todo", "fixme"], "location": "start"}], // disallow usage of configurable warning terms in comments": 2, // e.g. TODO or FIXME (off by default) + "no-with": 2, // disallow use of the with statement + "radix": 2, // require use of the second argument for parseInt() (off by default) + "vars-on-top": 2, // requires to declare all vars on top of their containing scope (off by default) + "wrap-iife": 2, // require immediate function invocation to be wrapped in parentheses (off by default) + "yoda": 2, // require or disallow Yoda conditions + "strict": 0, // controls location of Use Strict Directives. 0: required by `babel-eslint` + "no-catch-shadow": 2, // disallow the catch clause parameter name being the same as a variable in the outer scope (off by default in the node environment) + "no-delete-var": 2, // disallow deletion of variables + "no-label-var": 2, // disallow labels that share a name with a variable + "no-shadow": 2, // disallow declaration of variables already declared in the outer scope + "no-shadow-restricted-names": 2, // disallow shadowing of names such as arguments + "no-undef": 2, // disallow use of undeclared variables unless mentioned in a /*global */ block + "no-undef-init": 2, // disallow use of undefined when initializing variables + "no-undefined": 2, // disallow use of undefined variable (off by default) + "no-unused-vars": 2, // disallow declaration of variables that are not used in the code + "no-use-before-define": 2, // disallow use of variables before they are defined + "indent": [1, 2], // this option sets a specific tab width for your code (off by default) + "brace-style": 1, // enforce one true brace style (off by default) + "camelcase": 1, // require camel case names + "comma-spacing": [1, {"before": false, "after": true}], // enforce spacing before and after comma + "comma-style": [1, "last"], // enforce one true comma style (off by default) + "consistent-this": [1, "_this"], // enforces consistent naming when capturing the current execution context (off by default) + "eol-last": 1, // enforce newline at the end of file, with no multiple empty lines + "func-names": 0, // require function expressions to have a name (off by default) + "func-style": 0, // enforces use of function declarations or expressions (off by default) + "key-spacing": [1, {"beforeColon": false, "afterColon": true}], // enforces spacing between keys and values in object literal properties + "max-nested-callbacks": [1, 3], // specify the maximum depth callbacks can be nested (off by default) + "new-cap": [1, {newIsCap: true, capIsNew: false}], // require a capital letter for constructors + "new-parens": 1, // disallow the omission of parentheses when invoking a constructor with no arguments + "newline-after-var": 0, // allow/disallow an empty newline after var statement (off by default) + "no-array-constructor": 1, // disallow use of the Array constructor + "no-inline-comments": 1, // disallow comments inline after code (off by default) + "no-lonely-if": 1, // disallow if as the only statement in an else block (off by default) + "no-mixed-spaces-and-tabs": 1, // disallow mixed spaces and tabs for indentation + "no-multiple-empty-lines": [1, {"max": 2}], // disallow multiple empty lines (off by default) + "no-nested-ternary": 1, // disallow nested ternary expressions (off by default) + "no-new-object": 1, // disallow use of the Object constructor + "no-spaced-func": 1, // disallow space between function identifier and application + "no-ternary": 0, // disallow the use of ternary operators (off by default) + "no-trailing-spaces": 1, // disallow trailing whitespace at the end of lines + "no-underscore-dangle": 0, // disallow dangling underscores in identifiers + "one-var": [1, "never"], // allow just one var statement per function (off by default) + "operator-assignment": [1, "never"], // require assignment operator shorthand where possible or prohibit it entirely (off by default) + "padded-blocks": [1, "never"], // enforce padding within blocks (off by default) + "quote-props": [1, "as-needed"], // require quotes around object literal property names (off by default) + "quotes": [1, "single"], // specify whether double or single quotes should be used + "semi": [1, "always"], // require or disallow use of semicolons instead of ASI + "semi-spacing": [1, {"before": false, "after": true}], // enforce spacing before and after semicolons + "sort-vars": 0, // sort variables within the same declaration block (off by default) + "keyword-spacing": 2, // require a space after certain keywords (off by default) + "space-before-blocks": [1, "always"], // require or disallow space before blocks (off by default) + "space-before-function-paren": [1, {"anonymous": "always", "named": "never"}], // require or disallow space before function opening parenthesis (off by default) + "space-in-parens": [1, "never"], // require or disallow spaces inside parentheses (off by default) + "space-unary-ops": [1, {"words": true, "nonwords": false}], // Require or disallow spaces before/after unary operators (words on by default, nonwords off by default) + "wrap-regex": 0, // require regex literals to be wrapped in parentheses (off by default) + "no-var": 2, // require let or const instead of var (off by default) + "generator-star-spacing": [2, "before"], // enforce the spacing around the * in generator functions (off by default) + "max-depth": [2, 3], // specify the maximum depth that blocks can be nested (off by default) + "max-len": [2, 100, 2], // specify the maximum length of a line in your program (off by default) + "max-params": [2, 5], // limits the number of parameters that can be used in the function declaration. (off by default) + "max-statements": 0, // specify the maximum number of statement allowed in a function (off by default) + "no-bitwise": 0, // disallow use of bitwise operators (off by default) + "no-plusplus": 2, // disallow use of unary operators, ++ and -- (off by default), + "flow-vars/define-flow-type": 1, + "flow-vars/use-flow-type": 1 + }, + "env": { + "browser": true, + "node": true + } +} diff --git a/.flowconfig b/.flowconfig new file mode 100644 index 0000000..db3d868 --- /dev/null +++ b/.flowconfig @@ -0,0 +1,13 @@ +[ignore] +.*/node_modules/gulp-flowtype/* + +[include] + +[libs] +flow-typed + +[options] +suppress_comment= \\(.\\|\n\\)*\\$FlowExpectedError + +[version] +>=0.23 diff --git a/.gitignore b/.gitignore index eb298e0..ab6c460 100644 --- a/.gitignore +++ b/.gitignore @@ -13,8 +13,9 @@ lib-cov # Coverage directory used by tools like istanbul coverage -# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) -.grunt +# tmp folder +tmp +.tmp # Compiled binary addons (http://nodejs.org/api/addons.html) build/Release @@ -27,5 +28,6 @@ node_modules # Users Environment Variables .lock-wscript -*.jpg -!test/test.jpg +test.jpg + +.github diff --git a/.hound.yml b/.hound.yml new file mode 100644 index 0000000..bbeeb8b --- /dev/null +++ b/.hound.yml @@ -0,0 +1,5 @@ +javascript: + enabled: false +eslint: + enabled: true + config_file: .eslintrc diff --git a/.npmignore b/.npmignore new file mode 100644 index 0000000..78c74e2 --- /dev/null +++ b/.npmignore @@ -0,0 +1,31 @@ +# Logs +logs +*.log + +# Runtime data +pids +*.pid +*.seed + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage + +# tmp folder +tmp + +# Compiled binary addons (http://nodejs.org/api/addons.html) +build/Release + +# Dependency directory +# Commenting this out is preferred by some people, see +# https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git- +node_modules +bower_components +coverage +tmp + +# Users Environment Variables +.lock-wscript diff --git a/.travis.yml b/.travis.yml index 51b180d..59378a8 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,11 +1,10 @@ language: node_js node_js: - - '5' - - '4' - - '0.12' - '0.10' + - '0.12' + - '4' + - '5' sudo: false -notifications: - email: - on_success: always - on_failure: always +script: "gulp coverage" +after_success: + - cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..8622c1e --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1 @@ +### [1.0.0](https://github.com/riyadhalnur/node-base64-image/releases/tag/v1.0.0) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..c520b3d --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,65 @@ +# :eight_spoked_asterisk: :stars: :sparkles: :dizzy: :star2: :star2: :sparkles: :dizzy: :star2: :star2: Contributing :star: :star2: :dizzy: :sparkles: :star: :star2: :dizzy: :sparkles: :stars: :eight_spoked_asterisk: + +So, you want to contribute to this project! That's awesome. However, before +doing so, please read the following simple steps how to contribute. This will +make the life easier and will avoid wasting time on things which are not +requested. :sparkles: + +## Discuss the changes before doing them + - First of all, open an issue in the repository, using the [bug tracker][1], + describing the contribution you would like to make, the bug you found or any + other ideas you have. This will help us to get you started on the right + foot. + + - If it makes sense, add the platform and software information (e.g. operating + system, Node.JS version etc.), screenshots (so we can see what you are + seeing). + + - It is recommended to wait for feedback before continuing to next steps. + However, if the issue is clear (e.g. a typo) and the fix is simple, you can + continue and fix it. + +## Fixing issues + - Fork the project in your account and create a branch with your fix: + `some-great-feature` or `some-issue-fix`. + + - Commit your changes in that branch, writing the code following the + style used in this module. If the project contains tests (generally, the `test` + directory), you are encouraged to add a test as well. :memo: + + - If the project contains a `package.json` or a `bower.json` file add yourself + in the `contributors` array (or `authors` in the case of `bower.json`; + if the array does not exist, create it): + + ```json + { + "contributors": [ + "Your Name (http://your.website)" + ] + } + ``` + +## Creating a pull request + + - Open a pull request, and reference the initial issue in the pull request + message (e.g. *fixes #*). Write a good description and + title, so everybody will know what is fixed/improved. + + - If it makes sense, add screenshots, gifs etc., so it is easier to see what + is going on. + +## Wait for feedback +Before accepting your contributions, we will review them. You may get feedback +about what should be fixed in your modified code. If so, just keep committing +in your branch and the pull request will be updated automatically. + +## Everyone is happy! +Finally, your contributions will be merged, and everyone will be happy! :smile: +Contributions are more than welcome! + +Thanks! :sweat_smile: + + +[1]: https://github.com/riyadhalnur/node-base64-image/issues + +*Generated using [Blah](https://www.npmjs.com/package/blah)* diff --git a/LICENSE b/LICENSE index 17fb721..cff0f9c 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (c) Riyadh Al Nur (blog.verticalaxisbd.com) +Copyright (c) 2016 Riyadh Al Nur Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal @@ -9,13 +9,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md index 72fbded..8fdc31b 100644 --- a/README.md +++ b/README.md @@ -1,72 +1,29 @@ -[![Build Status](https://travis-ci.org/riyadhalnur/node-base64-image.svg?branch=master)](https://travis-ci.org/riyadhalnur/node-base64-image) +[![Build Status](https://travis-ci.org/riyadhalnur/node-base64-image.svg?branch=master)](https://travis-ci.org/riyadhalnur/node-base64-image) [![Coverage Status](https://coveralls.io/repos/github/riyadhalnur/node-base64-image/badge.svg?branch=master)](https://coveralls.io/github/riyadhalnur/node-base64-image?branch=master) +[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/riyadhalnur/node-base64-image?branch=master&svg=true)](https://ci.appveyor.com/project/riyadhalnur/node-base64-image?branch=master) node-base64-image ================= -Download images from remote URLs or use local images and encode/decode them to base64 +Download images from remote URLs or use local images and encode/decode them to Base64 string or [Buffer](https://nodejs.org/api/buffer.html) object -To install +### Installation `npm install node-base64-image --save` -To run tests -`npm test` - ### Usage +`var base64 = require('node-base64-image'); // ES5` -Require the library in your .js file -`var base64 = require('node-base64-image');` - -#### Download and encode an image -``` -var options = {string: true}; - -base64.base64encoder('www.someurl.com/image.jpg', options, function (err, image) { - if (err) { - console.log(err); - } - console.log(image); -}); -``` - -#### Encode a local image -``` -var path = __dirname + '/../test.jpg', - options = {localFile: true, string: true}; - -base64.base64encoder(path, options, function (err, image) { - if (err) { console.log(err); } - console.log(image); -}); -``` - - -##### Parameters - - `url` (string) - the url of the image to be downloaded and encoded. - - `options` (object) - - if `string` is passed is with 'true', the image returned will be a base64 string. Otherwise, the base64 buffer is returned. - - if `localFile` is passed is with 'true', a local image instead of a remote one will be used - - `callback` (function) - the callback will contain the err object and the encoded image object. - -#### Decode and write a base64 encoded image to disk -``` -var options = {filename: 'test'}; -var imageData = new Buffer('/9j/4AAQSkZJRgABAQAAAQABAAD...', 'base64'); +`import {encode, decode} from 'node-base64-image'; // ES6` -base64.base64decoder(imageData, options, function (err, saved) { - if (err) { console.log(err); } - console.log(saved); -}); -``` +### Documentation +Read the documentation in [DOCUMENTATION](docs/docs.md). -##### Parameters - - `imageData` (buffer) - the base64 image buffer. - - `options` (object) - contains the 'filename' property; this will be the written image file. - - `callback` (function) - the callback will contain the err object and the 'successful save' string. +### Contributing +Read the [CONTRIBUTING](CONTRIBUTING.md) guide for information. ### License -This library is licensed under the MIT license. +Licensed under MIT. See [LICENSE](LICENSE) for more information. ### Issues -Report a bug in the issues. +Report a bug in issues. -Lovingly crafted in Dhaka, Bangladesh by [Riyadh Al Nur](http://blog.verticalaxisbd.com) +Made with love in Dhaka, Bangladesh by [Riyadh Al Nur](https://verticalaxisbd.com) diff --git a/appveyor.yml b/appveyor.yml new file mode 100644 index 0000000..b59d7ff --- /dev/null +++ b/appveyor.yml @@ -0,0 +1,20 @@ +environment: + matrix: + - nodejs_version: "0.10" + - nodejs_version: "0.12" + - nodejs_version: "4" + - nodejs_version: "5" + +install: + - ps: Install-Product node $env:nodejs_version + - npm install -g gulp eslint + - npm install + +test_script: + - node --version + - npm --version + - npm test + +version: 1.0.{build} +skip_tags: true +build: off diff --git a/docs/docs.md b/docs/docs.md new file mode 100644 index 0000000..c5186a1 --- /dev/null +++ b/docs/docs.md @@ -0,0 +1,49 @@ +# fnCallback + +[src/node-base64-image.js:13-13](https://github.com/riyadhalnur/node-base64-image/blob/48ccb3a785ba53841dc0821548dff8177da7bfb0/src/node-base64-image.js#L13-L13 "Source code on GitHub") + +Callback for encode/decode functions + +**Parameters** + +- `Error` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** object +- `Response` **([string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String) \| [Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object))** string or Buffer object + +# encode + +[src/node-base64-image.js:27-65](https://github.com/riyadhalnur/node-base64-image/blob/48ccb3a785ba53841dc0821548dff8177da7bfb0/src/node-base64-image.js#L27-L65 "Source code on GitHub") + +Encodes a remote or local image to Base64 encoded string or Buffer + +**Parameters** + +- `url` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** URL of remote image or local path to image +- `options` **\[[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)]** Options object for extra configuration (optional, default `{}`) + - `options.string` **[boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Returns a Base64 encoded string. Defaults to Buffer object + - `options.local` **[boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Encode a local image file instead of a remote image +- `callback` **fnCallback** Callback function + +Returns **fnCallback** Returns the callback + +# result + +[src/node-base64-image.js:41-41](https://github.com/riyadhalnur/node-base64-image/blob/48ccb3a785ba53841dc0821548dff8177da7bfb0/src/node-base64-image.js#L41-L41 "Source code on GitHub") + +# result + +[src/node-base64-image.js:58-58](https://github.com/riyadhalnur/node-base64-image/blob/48ccb3a785ba53841dc0821548dff8177da7bfb0/src/node-base64-image.js#L58-L58 "Source code on GitHub") + +# decode + +[src/node-base64-image.js:77-89](https://github.com/riyadhalnur/node-base64-image/blob/48ccb3a785ba53841dc0821548dff8177da7bfb0/src/node-base64-image.js#L77-L89 "Source code on GitHub") + +Decodes an base64 encoded image buffer and saves it to disk + +**Parameters** + +- `imageBuffer` **[Buffer](https://nodejs.org/api/buffer.html)** Image Buffer object +- `options` **\[[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)]** Options object for extra configuration (optional, default `{}`) + - `options.filename` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Filename for the final image file +- `callback` **fnCallback** Callback function + +Returns **fnCallback** Returns the callback diff --git a/gulpfile.babel.js b/gulpfile.babel.js new file mode 100644 index 0000000..ed7c068 --- /dev/null +++ b/gulpfile.babel.js @@ -0,0 +1,246 @@ +import gulp from 'gulp'; +import loadPlugins from 'gulp-load-plugins'; +import {execFile} from 'child_process'; +import flow from 'flow-bin'; +import del from 'del'; +import glob from 'glob'; +import path from 'path'; +import {Instrumenter} from 'isparta'; +import webpack from 'webpack'; +import webpackStream from 'webpack-stream'; +// import source from 'vinyl-source-stream'; + +import mochaGlobals from './test/setup/.globals'; +import manifest from './package.json'; + +// Load all of our Gulp plugins +const $ = loadPlugins(); + +// Gather the library data from `package.json` +const config = manifest.babelBoilerplateOptions; +const mainFile = manifest.main; +const destinationFolder = path.dirname(mainFile); +const exportFileName = path.basename(mainFile, path.extname(mainFile)); + +function cleanDist(done) { + del([destinationFolder]).then(() => done()); +} + +function cleanTmp(done) { + del(['tmp']).then(() => done()); +} + +function onError() { + $.util.beep(); +} + +// Lint a set of files +function lint(files) { + return gulp.src(files) + .pipe($.plumber()) + .pipe($.eslint()) + .pipe($.eslint.format()) + .pipe($.eslint.failOnError()) + .on('error', onError); +} + +function lintSrc() { + return lint('src/**/*.js'); +} + +function lintTest() { + return lint('test/**/*.js'); +} + +function lintGulpfile() { + return lint('gulpfile.babel.js'); +} + +function build() { + return gulp.src(path.join('src', config.entryFileName + '.js')) + .pipe($.plumber()) + .pipe(webpackStream({ + output: { + filename: exportFileName + '.js', + libraryTarget: 'umd', + library: config.mainVarName + }, + module: { + loaders: [ + { test: /\.js$/, exclude: /node_modules/, loader: 'babel-loader' } + ] + }, + devtool: 'source-map' + })) + .pipe(gulp.dest(destinationFolder)) + .pipe($.filter(['*', '!**/*.js.map'])) + .pipe($.rename(exportFileName + '.min.js')) + .pipe($.sourcemaps.init({ loadMaps: true })) + .pipe($.uglify()) + .pipe($.sourcemaps.write('./')) + .pipe(gulp.dest(destinationFolder)); +} + +function _mocha() { + return gulp.src(['test/setup/node.js', 'test/unit/**/*.js'], {read: false}) + .pipe($.mocha({ + reporter: 'spec', + globals: Object.keys(mochaGlobals.globals), + ignoreLeaks: false + })); +} + +// Thank you @hallettj for this +function _runFlow(cmd, callback) { + execFile(flow, cmd, { + cwd: module.__dirname + }, function (err, stdout, stderr) { + if (err && stdout.length > 0) { + return callback(new $.util.PluginError('flow', stdout)); + } else if (err) { + $.util.log(stderr); + return callback(err); + } else { // eslint-disable-line + callback(); + } + }); +} + +function _registerBabel() { + require('babel-register'); +} + +function test() { + _registerBabel(); + return _mocha(); +} + +function coverage(done) { + _registerBabel(); + gulp.src(['src/**/*.js']) + .pipe($.istanbul({ instrumenter: Instrumenter })) + .pipe($.istanbul.hookRequire()) + .on('finish', () => { + return test() + .pipe($.istanbul.writeReports()) + .on('end', done); + }); +} + +function typeCheck(done) { + _registerBabel(); + _runFlow(['start'], function () { + _runFlow(['status', '--no-auto-start'], done); + }); +} + +function gitTag() { + _registerBabel(); + return gulp.src(['./package.json']) + .pipe($.tagVersion()); +} + +function generateDocs() { + _registerBabel(); + return gulp.src('src/node-base64-image.js') + .pipe($.documentation({ format: 'md', filename: 'docs.md' })) + .pipe(gulp.dest('docs')); +} + +const watchFiles = ['src/**/*', 'test/**/*', 'package.json', '**/.eslintrc']; + +// Run the headless unit tests as you make changes. +function watch() { + gulp.watch(watchFiles, ['test']); +} + +function testBrowser() { + // Our testing bundle is made up of our unit tests, which + // should individually load up pieces of our application. + // We also include the browser setup file. + const testFiles = glob.sync('./test/unit/**/*.js'); + const allFiles = ['./test/setup/browser.js'].concat(testFiles); + + // Lets us differentiate between the first build and subsequent builds + let firstBuild = true; + + // This empty stream might seem like a hack, but we need to specify all of our files through + // the `entry` option of webpack. Otherwise, it ignores whatever file(s) are placed in here. + return gulp.src('') + .pipe($.plumber()) + .pipe(webpackStream({ + watch: true, + entry: allFiles, + output: { + filename: '__spec-build.js' + }, + module: { + loaders: [ + // This is what allows us to author in future JavaScript + { test: /\.js$/, exclude: /node_modules/, loader: 'babel-loader' }, + // This allows the test setup scripts to load `package.json` + { test: /\.json$/, exclude: /node_modules/, loader: 'json-loader' } + ] + }, + plugins: [ + // By default, webpack does `n=>n` compilation with entry files. This concatenates + // them into a single chunk. + new webpack.optimize.LimitChunkCountPlugin({ maxChunks: 1 }) + ], + devtool: 'inline-source-map' + }, null, function () { + if (firstBuild) { + $.livereload.listen({port: 35729, host: 'localhost', start: true}); + // let watcher = gulp.watch(watchFiles, ['lint']); + } else { + $.livereload.reload('./tmp/__spec-build.js'); + } + firstBuild = false; + })) + .pipe(gulp.dest('./tmp')); +} + +// Remove the built files +gulp.task('clean', cleanDist); + +// Remove our temporary files +gulp.task('clean-tmp', cleanTmp); + +// Lint our source code +gulp.task('lint-src', lintSrc); + +// Lint our test code +gulp.task('lint-test', lintTest); + +// Lint this file +gulp.task('lint-gulpfile', lintGulpfile); + +// Lint everything +gulp.task('lint', ['lint-src', 'lint-test', 'lint-gulpfile']); + +// Build two versions of the library +gulp.task('build', ['lint', 'clean'], build); + +// Lint and run our tests +gulp.task('test', ['lint', 'flow'], test); + +// Set up coverage and run tests +gulp.task('coverage', ['lint'], coverage); + +// Set up type checking using flow +gulp.task('flow', typeCheck); + +// Tag with version in package.json +gulp.task('tag', gitTag); + +// Generate documentation +gulp.task('doc', generateDocs); + +// Set up a livereload environment for our spec runner `test/runner.html` +gulp.task('test-browser', ['lint', 'clean-tmp'], testBrowser); + +// Run the headless unit tests as you make changes. +gulp.task('watch', watch); + +// An alias of test +gulp.task('default', ['test']); diff --git a/index.js b/index.js deleted file mode 100644 index ec5bd9f..0000000 --- a/index.js +++ /dev/null @@ -1,64 +0,0 @@ -'use strict'; - -var request = require('request'); -var fs = require('fs'); - -var base64encoder = function (url, options, callback) { - options = options || {}; - - if (typeof callback !== 'function') { - throw new Error('Callback needs to be a function!'); - } - - if (url === undefined || url === null) { - throw new Error('URL cannot be empty!'); - } - - var encoder = function (body, options) { - var image; - - if (options && options.string === true) { - image = body.toString('base64'); - return callback(null, image); - } else { - image = new Buffer(body, 'base64'); - return callback(null, image); - } - }; - - if (options && options.localFile === true) { - fs.readFile(url, function (err, data) { - if (err) { return callback(err); } - - return encoder(data, options); - }); - } else { - request({url: url, encoding: null}, function (err, res, body) { - if (err) { return callback(err); } - - if (body && res.statusCode === 200) { - return encoder(body, options); - } else { - if (!body) { return callback('Image loading error - empty body'); } - else { return callback('Image loading error - ' + res.statusCode); } - } - }); - } - -}; - -var base64decoder = function (imageBuffer, options, callback) { - options = options || {}; - - if (options && options.filename) { - fs.writeFile(options.filename + '.jpg', imageBuffer, 'base64', function (err) { - if (err) { return callback(err); } - return callback(null, 'Image saved successfully to disk!'); - }); - } -}; - -module.exports = { - base64encoder: base64encoder, - base64decoder: base64decoder -}; diff --git a/package.json b/package.json index 6e1eb48..9280364 100644 --- a/package.json +++ b/package.json @@ -1,16 +1,23 @@ { "name": "node-base64-image", - "version": "0.1.2", + "version": "1.0.0", "description": "Download images from remote URLs and encode/decode them to base64", - "main": "index.js", + "main": "dist/index.js", "scripts": { - "test": "mocha test/tests.js" + "test": "gulp", + "lint": "gulp lint", + "test-browser": "gulp test-browser", + "watch": "gulp watch", + "build": "gulp build", + "coverage": "gulp coverage", + "tag": "gulp tag", + "doc": "gulp doc", + "prepublish": "npm run build && npm run coverage && npm run tag" }, - "engines": { - "node": ">=0.10" + "repository": { + "type": "git", + "url": "https://github.com/riyadhalnur/node-base64-image.git" }, - "repository": "https://github.com/riyadhalnur/node-base64-image", - "homepage": "http://riyadhalnur.github.io/node-base64-image/", "keywords": [ "image", "download", @@ -20,16 +27,58 @@ "javascript", "node" ], - "bugs": { - "url": "https://github.com/riyadhalnur/node-base64-image/issuess" - }, - "author": "Riyadh Al Nur (http://blog.verticalaxisbd.com)", + "author": "Riyadh Al Nur (https://riyadhalnur.com)", "license": "MIT", - "dependencies": { - "request": "^2.51.x" + "bugs": { + "url": "https://github.com/riyadhalnur/node-base64-image/issues" }, + "homepage": "http://riyadhalnur.github.io/node-base64-image/", "devDependencies": { - "mocha": "^2.0.x", - "should": "^4.3.x" + "babel-core": "^6.3.26", + "babel-eslint": "6.0.4", + "babel-loader": "^6.2.0", + "babel-plugin-transform-flow-strip-types": "6.7.0", + "babel-polyfill": "^6.3.14", + "babel-preset-es2015": "^6.3.13", + "babel-register": "^6.3.13", + "chai": "^3.4.1", + "coveralls": "2.11.9", + "del": "^2.2.0", + "eslint": "2.10.2", + "eslint-plugin-flow-vars": "0.4.0", + "flow-bin": "0.25.0", + "glob": "^6.0.3", + "gulp": "^3.9.0", + "gulp-babel": "^6.1.1", + "gulp-documentation": "2.2.0", + "gulp-eslint": "^2.0.0", + "gulp-filter": "^3.0.0", + "gulp-istanbul": "^0.10.3", + "gulp-livereload": "^3.8.1", + "gulp-load-plugins": "^1.1.0", + "gulp-mocha": "^2.2.0", + "gulp-plumber": "^1.0.1", + "gulp-rename": "^1.2.2", + "gulp-sourcemaps": "^1.6.0", + "gulp-tag-version": "1.3.0", + "gulp-uglify": "^1.5.1", + "gulp-util": "^3.0.7", + "isparta": "^4.0.0", + "json-loader": "^0.5.3", + "mocha": "^2.3.4", + "sinon": "^1.17.2", + "sinon-chai": "^2.8.0", + "vinyl-source-stream": "^1.1.0", + "webpack": "^1.12.9", + "webpack-stream": "^3.1.0" + }, + "babelBoilerplateOptions": { + "entryFileName": "node-base64-image", + "mainVarName": "base64" + }, + "dependencies": { + "lodash": "4.11.1", + "polygoat": "1.1.4", + "request": "2.72.0" } } diff --git a/src/node-base64-image.js b/src/node-base64-image.js new file mode 100644 index 0000000..8f7e6f9 --- /dev/null +++ b/src/node-base64-image.js @@ -0,0 +1,89 @@ +/* @flow */ +import request from 'request'; +import _ from 'lodash'; +import {readFile as read, writeFile as write} from 'fs'; + +/** + * Callback for encode/decode functions + * + * @callback fnCallback + * @param {Object} Error object + * @param {(string|Object)} Response string or Buffer object + */ +type Callback = (err: ?Error, x?: T) => void; + +/** + * Encodes a remote or local image to Base64 encoded string or Buffer + * + * @name encode + * @param {string} url - URL of remote image or local path to image + * @param {Object} [options={}] - Options object for extra configuration + * @param {boolean} options.string - Returns a Base64 encoded string. Defaults to Buffer object + * @param {boolean} options.local - Encode a local image file instead of a remote image + * @param {fnCallback} callback - Callback function + * @todo Option to wrap string every 76 characters for strings larger than 76 characters + * @return {fnCallback} - Returns the callback + */ +export function encode(url: string, options: Object = {string: false, local: false}, callback: Callback) { // eslint-disable-line + if (_.isUndefined(url) || _.isNull(url) || !_.isString(url)) { + return callback(new Error('URL is undefined or not properly formatted')); + } + + if (options.local) { + read(url, (err, body) => { + if (err) { + return callback(err); + } + + /** + * @todo Handle this better. + */ + let result = options.string ? body.toString('base64') : new Buffer(body, 'base64'); + return callback(null, result); + }); + } else { + request({ url: url, encoding: null }, (err, response, body) => { + if (err) { + return callback(err); + } + + if (!body) { + return callback(new Error('Error retrieving image - Empty Body!')); + } + + if (body && response.statusCode === 200) { + /** + * @todo Handle this better. + */ + let result = options.string ? body.toString('base64') : new Buffer(body, 'base64'); + return callback(null, result); + } + + return callback(new Error('Error retrieving image - Status Code ' + response.statusCode)); + }); + } +} + +/** + * Decodes an base64 encoded image buffer and saves it to disk + * + * @name decode + * @param {Buffer} imageBuffer - Image Buffer object + * @param {Object} [options={}] - Options object for extra configuration + * @param {string} options.filename - Filename for the final image file + * @param {fnCallback} callback - Callback function + * @return {fnCallback} - Returns the callback + */ +export function decode(imageBuffer: any, options: Object = {filename: 'saved-image'}, callback: Callback) { // eslint-disable-line + if (!_.isBuffer(imageBuffer)) { + return callback(new Error('The image is not a Buffer object type')); + } + + write(options.filename + '.jpg', imageBuffer, 'base64', (err) => { + if (err) { + return callback(err); + } + + return callback(null, 'Image saved successfully to disk!'); + }); +} diff --git a/test/.eslintrc b/test/.eslintrc new file mode 100644 index 0000000..00597af --- /dev/null +++ b/test/.eslintrc @@ -0,0 +1,14 @@ +{ + extends: "./setup/.globals.json", + "parser": "babel-eslint", + "rules": { + "strict": 0, + "quotes": [2, "single"], + "no-unused-expressions": 0 + }, + "env": { + "browser": true, + "node": true, + "mocha": true + } +} diff --git a/test/runner.html b/test/runner.html new file mode 100644 index 0000000..371619b --- /dev/null +++ b/test/runner.html @@ -0,0 +1,28 @@ + + + + + + Tests + + + + + + + + + + + + + + + + + + + +
+ + diff --git a/test/setup/.globals.json b/test/setup/.globals.json new file mode 100644 index 0000000..8a30f4e --- /dev/null +++ b/test/setup/.globals.json @@ -0,0 +1,14 @@ +{ + "globals": { + "expect": true, + "should": true, + "mock": true, + "sandbox": true, + "spy": true, + "stub": true, + "useFakeServer": true, + "useFakeTimers": true, + "useFakeXMLHttpRequest": true, + "timeout": 15000 + } +} diff --git a/test/setup/browser.js b/test/setup/browser.js new file mode 100644 index 0000000..a87155b --- /dev/null +++ b/test/setup/browser.js @@ -0,0 +1,9 @@ +let mochaGlobals = require('./.globals.json').globals; + +window.mocha.setup('bdd'); +window.onload = function () { + window.mocha.checkLeaks(); + window.mocha.globals(Object.keys(mochaGlobals)); + window.mocha.run(); + require('./setup')(window); +}; diff --git a/test/setup/node.js b/test/setup/node.js new file mode 100644 index 0000000..c19a2fd --- /dev/null +++ b/test/setup/node.js @@ -0,0 +1,9 @@ +let chai = require('chai'); + +global.chai = chai; +global.sinon = require('sinon'); +global.chai.use(require('sinon-chai')); +global.should = chai.should(); + +require('babel-core/register'); +require('./setup')(); diff --git a/test/setup/setup.js b/test/setup/setup.js new file mode 100644 index 0000000..39858aa --- /dev/null +++ b/test/setup/setup.js @@ -0,0 +1,22 @@ +module.exports = function (root) { + root = root ? root : global; + root.expect = root.chai.expect; + + beforeEach(function () { + // Using these globally-available Sinon features is preferrable, as they're + // automatically restored for you in the subsequent `afterEach` + root.sandbox = root.sinon.sandbox.create(); + root.stub = root.sandbox.stub.bind(root.sandbox); + root.spy = root.sandbox.spy.bind(root.sandbox); + root.mock = root.sandbox.mock.bind(root.sandbox); + root.useFakeTimers = root.sandbox.useFakeTimers.bind(root.sandbox); + root.useFakeXMLHttpRequest = root.sandbox.useFakeXMLHttpRequest.bind(root.sandbox); + root.useFakeServer = root.sandbox.useFakeServer.bind(root.sandbox); + }); + + afterEach(function () { + delete root.stub; + delete root.spy; + root.sandbox.restore(); + }); +}; diff --git a/test/test.jpg b/test/test.jpg deleted file mode 100644 index fac43c0..0000000 Binary files a/test/test.jpg and /dev/null differ diff --git a/test/tests.js b/test/tests.js deleted file mode 100644 index d341890..0000000 --- a/test/tests.js +++ /dev/null @@ -1,129 +0,0 @@ -'use strict'; - -var should = require('should'); -var base64Image = require('../index'); - -describe('Image download and encode/decode to Base64', function () { - describe('Base64 Encoder', function () { - it('should throw an error if callback is not a function', function (done) { - var url, options, callback; - - var helperFunc = function () { - base64Image.base64encoder(url, options, callback); - }; - - helperFunc.should.throw(Error); - helperFunc.should.throw('Callback needs to be a function!'); - - done(); - }); - - it('should throw an error if url is null or undefined', function (done) { - var url = undefined, options; - - var helperFunc = function () { - base64Image.base64encoder(url, options, function (err, image) { - err.should.exist; - image.should.not.exist; - }); - }; - - helperFunc.should.throw(Error); - helperFunc.should.throw('URL cannot be empty!'); - - done(); - }); - - it('should report if image could not be loaded', function (done) { - var url = 'http://www.pctools.com/security-news/wp-content/uploads/2011/09/nonExisting404.jpg', options; - - base64Image.base64encoder(url, options, function (err, image) { - err.should.exist; - should.not.exist(image); - - done(); - }); - - }); - - it('should download an image and return base64 encoded Buffer', function (done) { - this.timeout(15000); - - var url = 'http://www.pctools.com/security-news/wp-content/uploads/2011/09/code.jpg', options = {}; - - base64Image.base64encoder(url, options, function (err, image) { - should.not.exist(err); - - image.should.exist; - image.should.be.an.instanceOf(Buffer); - - done(); - }); - }); - - - it('should download an image and return base64 encoded string', function (done) { - this.timeout(15000); - - var url = 'http://www.pctools.com/security-news/wp-content/uploads/2011/09/code.jpg', options = {string: true}; - - base64Image.base64encoder(url, options, function (err, image) { - should.not.exist(err); - - image.should.exist; - image.should.match(/^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/); - - done(); - }); - }); - - it('should use a local image and return base64 encoded Buffer', function (done) { - this.timeout(15000); - - var path = __dirname + '/test.jpg', - options = {localFile: true}; - - base64Image.base64encoder(path, options, function (err, image) { - should.not.exist(err); - - image.should.exist; - image.should.be.an.instanceOf(Buffer); - - done(); - }); - }); - - it('should use a local image and return base64 encoded string', function (done) { - this.timeout(15000); - - var path = __dirname + '/test.jpg', - options = {localFile: true, string: true}; - - base64Image.base64encoder(path, options, function (err, image) { - should.not.exist(err); - - image.should.exist; - image.should.match(/^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/); - - done(); - }); - }); - - }); - - describe('Base64 Decoder', function () { - it('should decode a base64 image and save to disk', function (done) { - var options = {filename: 'test'}; - var imageData = new Buffer('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', 'base64'); - - base64Image.base64decoder(imageData, options, function (err, saved) { - should.not.exist(err); - - saved.should.exist; - saved.should.equal('Image saved successfully to disk!'); - - done(); - }); - }); - }); -}); \ No newline at end of file diff --git a/test/unit/node-base64-image.js b/test/unit/node-base64-image.js new file mode 100644 index 0000000..a48ac98 --- /dev/null +++ b/test/unit/node-base64-image.js @@ -0,0 +1,140 @@ +import {encode, decode} from '../../src/node-base64-image.js'; + +describe('Base64 Image decode/encode', () => { + it('should exist', () => { + should.exist(encode); + should.exist(decode); + }); + + describe('Encoder', () => { + it('should return an error if callback is not a function', (done) => { + let url; + let options = {}; + let callback; + + (function () { + encode(url, options, callback); + }).should.throw(TypeError); + + done(); + }); + + it('should return an error if url is null or undefined', (done) => { + let url; + let options = {}; + + encode(url, options, (err, image) => { + err.should.exist; + err.message.should.equal('URL is undefined or not properly formatted'); + + should.not.exist(image); + done(); + }); + }); + + it('should return an error if local image could not be loaded', (done) => { + let url = __dirname + '/noimage.jpg'; + let options = {local: true}; + + encode(url, options, (err, image) => { + err.should.exist; + + should.not.exist(image); + done(); + }); + }); + + it('should return an error if remote image could not be loaded', (done) => { + let url = 'https://verticalaxisbd.com/noimage.jpg'; + let options = {}; + + encode(url, options, (err, image) => { + err.should.exist; + err.message.should.equal('Error retrieving image - Status Code 404'); + + should.not.exist(image); + done(); + }); + }); + + it('should download an image and return the Base64 encoded string', function (done) { + let url = 'https://res.cloudinary.com/verticalaxisbd/image/upload/h_239,w_239/rg1kxkgxayhdgoqdaejz.jpg'; // eslint-disable-line + let options = {string: true}; + + encode(url, options, (err, image) => { + should.not.exist(err); + + image.should.exist; + image.should.match(/^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/); + done(); + }); + }); + + it('should download an image and return the Buffer object by default', function (done) { + let url = 'https://res.cloudinary.com/verticalaxisbd/image/upload/h_239,w_239/rg1kxkgxayhdgoqdaejz.jpg'; // eslint-disable-line + let options = {}; + + encode(url, options, (err, image) => { + should.not.exist(err); + + image.should.exist; + image.should.be.an.instanceOf(Buffer); + done(); + }); + }); + + it('should encode local image and return the Buffer object by default', (done) => { + let path = __dirname + '/test.jpg'; + let options = {local: true}; + + encode(path, options, (err, image) => { + should.not.exist(err); + + image.should.exist; + image.should.be.an.instanceOf(Buffer); + done(); + }); + }); + + it('should encode local image and return the Base64 encoded string', (done) => { + let path = __dirname + '/test.jpg'; + let options = {local: true, string: true}; + + encode(path, options, (err, image) => { + should.not.exist(err); + + image.should.exist; + image.should.match(/^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/); + done(); + }); + }); + }); + + describe('Decoder', () => { + it('should return an error if image is not a Buffer object', (done) => { + let imageData; + let options = {}; + + decode(imageData, options, (err, response) => { + err.should.exist; + err.message.should.equal('The image is not a Buffer object type'); + + should.not.exist(response); + done(); + }); + }); + + it('should decode a Base64 encoded image and save it to disk', (done) => { + let options = {filename: 'test'}; + let imageData = new Buffer('/9j/4AAQSkZJRgABAQAAAQABAAD/2w//Z', 'base64'); + + decode(imageData, options, (err, response) => { + should.not.exist(err); + + response.should.exist; + response.should.equal('Image saved successfully to disk!'); + done(); + }); + }); + }); +}); diff --git a/test/unit/test.jpg b/test/unit/test.jpg new file mode 100644 index 0000000..9ac3bba Binary files /dev/null and b/test/unit/test.jpg differ