@donkeylabs/server 0.2.9 → 0.2.11

package/examples/starter/node_modules/git-diff/README.md

@@ -0,0 +1,218 @@
+# git-diff
+
+<br>[![Linux Build](https://img.shields.io/travis/danday74/git-diff/master.svg?label=linux)](https://travis-ci.org/danday74/git-diff)
+[![Windows Build](https://img.shields.io/appveyor/ci/danday74/git-diff/master.svg?label=windows)](https://ci.appveyor.com/project/danday74/git-diff)
+[![Coverage Status](https://coveralls.io/repos/github/danday74/git-diff/badge.svg)](https://coveralls.io/github/danday74/git-diff)
+<br>[![npm](https://img.shields.io/npm/v/git-diff.svg)](https://www.npmjs.com/package/git-diff)
+[![Dependencies Status](https://david-dm.org/danday74/git-diff/status.svg)](https://david-dm.org/danday74/git-diff)
+[![npm](https://img.shields.io/npm/dm/git-diff.svg)](https://www.npmjs.com/package/git-diff)
+[![node](https://img.shields.io/node/v/git-diff.svg)](https://www.npmjs.com/package/git-diff)
+
+**Returns the git diff of two strings**
+
+
+
+<br>
+
+## Introduction
+
+git-diff will use ```git``` (if installed) and ```printf``` (if available) to get the real git diff of two strings, viz the actual diff output produced by git itself.
+
+As a fallback, if either command is unavailable, git-diff will instead use the [diff](https://www.npmjs.com/package/diff) module to produce a very good fake git diff.
+
+If desired, you may then console.log the returned git diff. An example of **actual output**:
+
+![Line diff v Word diff](diffs.png "Line diff v Word diff")
+
+
+
+<br>
+
+## Usage
+
+`npm install --save git-diff`
+
+git-diff takes 3 arguments, the **old string** to diff, the **new string** to diff and optionally an [options object](#options-object)
+
+git-diff returns the git difference or `undefined` where there is no difference.
+
+String diff example usage:
+
+```javascript 1.5
+var gitDiff = require('git-diff')
+var oldStr = 'fred\nis\nfunny\n'
+var newStr = 'paul\nis\nfunny\n'
+var diff = gitDiff(oldStr, newStr)
+
+var assert = require('assert')
+assert.equal(diff, '@@ -1,3 +1,3 @@\n-fred\n+paul\n is\n funny\n')
+```
+
+File diff example usage:
+
+```javascript 1.5
+var gitDiff = require('git-diff')
+var readFileGo = require('readfile-go') // or your preferred file reader
+var oldStr = readFileGo(__dirname + '/oldStr.txt')
+var newStr = readFileGo(__dirname + '/newStr.txt')
+var diff = gitDiff(oldStr, newStr)
+```
+
+
+
+<br>
+
+## Options object
+
+Available options are:
+
+color | [flags](#flags-string--null-) | [forceFake](#forcefake-boolean-) | noHeaders | [save](#save-boolean-) | wordDiff
+
+Default options are:
+
+```javascript 1.5
+var options = {
+  color: false,      // Add color to the git diff returned?
+  flags: null,       // A space separated string of git diff flags from https://git-scm.com/docs/git-diff#_options
+  forceFake: false,  // Do not try and get a real git diff, just get me a fake? Faster but may not be 100% accurate
+  noHeaders: false,  // Remove the ugly @@ -1,3 +1,3 @@ header?
+  save: false,       // Remember the options for next time?
+  wordDiff: false    // Get a word diff instead of a line diff?
+}
+```
+
+Further assistance is given below for options that are not self explanatory.
+
+
+
+<br>
+
+#### **flags** (string | null) [![top](top.png)](#options-object)
+
+The flags option allows you to use any [git diff flags](https://git-scm.com/docs/git-diff#_options)
+
+This only applies to real git diffs and will not effect the output if it is fake.
+
+An example to illustrate:
+
+```javascript 1.5
+var gitDiff = require('git-diff')
+var oldStr = 'fred\n   is   \nfunny\n'
+var newStr = 'paul\nis\n   funny   \n'
+var diff = gitDiff(oldStr, newStr, {flags: '--diff-algorithm=minimal --ignore-all-space'})
+
+var assert = require('assert')
+assert.equal(diff, '@@ -1,3 +1,3 @@\n-fred\n+paul\n is\n    funny   \n')
+```
+
+Here, the use of ```--ignore-all-space``` prevents a difference being reported on the 2nd and 3rd lines.
+
+
+
+<br>
+
+#### **forceFake** (boolean) [![top](top.png)](#options-object)
+
+git-diff will initially attempt to use ```git``` and ```printf``` to get the real git diff.
+
+If it cannot, it instead returns a very good fake git diff.
+
+A fake git diff is faster to produce but may not be 100% representative of a real git diff.
+
+The [flags](#flags-string--null-) option is ignored when faking and fake diffs never have a header.
+
+However, if a fake is good enough and speed is of the essence then you may want to force a fake git diff.
+
+The forceFake option allows you to do exactly that:
+
+```javascript 1.5
+var gitDiff = require('git-diff')
+var oldStr = 'fred\nis\nfunny\n'
+var newStr = 'paul\nis\nfunny\n'
+var diff = gitDiff(oldStr, newStr, {forceFake: true})
+
+var assert = require('assert')
+assert.equal(diff, '-fred\n+paul\n is\n funny\n')
+```
+
+
+
+<br>
+
+#### **save** (boolean) [![top](top.png)](#options-object)
+
+Its annoying to keep passing the same options every time.
+
+git-diff, if instructed to do so, will remember previously used options for you.
+
+When the `{save: true}` option is used in a call to git-diff subsequent calls remember the options.
+
+```javascript 1.5
+var gitDiff = require('git-diff')
+var oldStr = 'fred\nis\nfunny\n'
+var newStr = 'paul\nis\nfunny\n'
+var diff1 = gitDiff(oldStr, newStr, {save: true, wordDiff: true})
+var diff2 = gitDiff(oldStr, newStr)
+
+var assert = require('assert')
+assert.equal(diff1, '@@ -1,3 +1,3 @@\n[-fred-]{+paul+}\nis\nfunny\n')
+assert.equal(diff2, '@@ -1,3 +1,3 @@\n[-fred-]{+paul+}\nis\nfunny\n')
+```
+
+Here, the second call remembers that the wordDiff option is on. `{wordDiff: true}` is now the default.
+
+
+
+<br>
+
+## Async execution
+
+git-diff offers a promise based async solution:
+
+```javascript 1.5
+var gitDiff = require('git-diff/async')
+var oldStr = 'fred\nis\nfunny\n'
+var newStr = 'paul\nis\nfunny\n'
+gitDiff(oldStr, newStr).then(function(diff) {
+  var assert = require('assert')
+  assert.equal(diff, '@@ -1,3 +1,3 @@\n-fred\n+paul\n is\n funny\n')
+})
+```
+
+
+
+<br>
+
+## FAQs
+
+> **How good is the fake git diff?**<br>
+> The diff module used for the fake diff does not use the same difference algorithm as git.
+> As such, a line diff is likely to be identical to a git line diff whereas a word diff will have some variance.
+
+> **How can I tell whether the returned git diff is real or fake?**<br>
+> If the ```@@ -1,3 +1,3 @@``` header is present then the returned git diff is real.<br>
+> If the header is absent then either the [noHeaders](#options-object) option is on or the returned git diff is fake.
+
+> **Will my environment produce a real or fake git diff?**<br>
+> Linux and mac have the coveted ```printf``` command available. On Windows [git bash](https://git-for-windows.github.io) makes ```printf``` accessible.<br>
+> Assuming that git is installed, any of these environments will produce a real git diff.
+
+
+
+<br>
+
+## Author says
+
+What's the **difference** between how God treats the righteous and the wicked?
+
+> And God saw that the light was good. And God separated the light from the darkness. [Genesis 1:4 ESV](https://www.biblegateway.com/passage/?search=Genesis+1%3A4&version=ESV)
+
+And He will do it again:
+
+> Let both grow together until the harvest, and at harvest time I will tell the reapers, “Gather the weeds first and bind them in bundles to be burned, but gather the wheat into my barn.” [Matthew 13:30 ESV](https://www.biblegateway.com/passage/?search=matthew+13%3A30&version=ESV)
+
+Much love :D
+
+
+
+<br><br><br><br><br>

package/examples/starter/node_modules/git-diff/appveyor.yml

@@ -0,0 +1,17 @@
+environment:
+  matrix:
+    - nodejs_version: '8'
+    - nodejs_version: '6'
+    - nodejs_version: '4'
+    - nodejs_version: '4.8.0'
+
+install:
+  - ps: Install-Product node $env:nodejs_version
+  - yarn
+
+test_script:
+  - node --version
+  - npm --version
+  - npm test
+
+build: off

package/examples/starter/node_modules/git-diff/async.js

@@ -0,0 +1,14 @@
+'use strict'
+
+require('./server.bootstrap')
+
+var gitDiffSync = require('./sync')
+
+var gitDiffAsync = function(str1, str2, options) {
+  return new Promise(function(resolve) {
+    var gitDiff = gitDiffSync(str1, str2, options)
+    resolve(gitDiff)
+  })
+}
+
+module.exports = gitDiffAsync

package/examples/starter/node_modules/git-diff/config.js

@@ -0,0 +1,8 @@
+'use strict'
+
+var config = {
+  testing: process.env.NODE_ENV === 'test',
+  gitDiffOptionsUrl: 'https://git-scm.com/docs/git-diff#_options'
+}
+
+module.exports = config

package/examples/starter/node_modules/git-diff/js/_shared/defaultOptions.js

@@ -0,0 +1,10 @@
+'use strict'
+
+module.exports = Object.seal({
+  color: false, // fake real
+  flags: null, // real
+  forceFake: false, // git-diff
+  noHeaders: false, // real
+  save: false, // git-diff
+  wordDiff: false // fake real
+})

package/examples/starter/node_modules/git-diff/js/gitDiffFake/color.js

@@ -0,0 +1,14 @@
+'use strict'
+
+var chalk = require('chalk')
+var config = require('../../config')
+
+function Color() {
+  this.add = function(str, color) {
+    /* istanbul ignore next */
+    if (!config.testing) str = chalk[color](str)
+    return str
+  }
+}
+
+module.exports = new Color()

package/examples/starter/node_modules/git-diff/js/gitDiffFake/index.js

@@ -0,0 +1,10 @@
+'use strict'
+
+var lineDiffFake = require('./lineDiffFake')
+var wordDiffFake = require('./wordDiffFake')
+
+function gitDiffFake(str1, str2, options) {
+  return (options.wordDiff) ? wordDiffFake(str1, str2, options) : lineDiffFake(str1, str2, options)
+}
+
+module.exports = gitDiffFake

package/examples/starter/node_modules/git-diff/js/gitDiffFake/index.spec.js

@@ -0,0 +1,74 @@
+'use strict'
+
+var gitDiffFake = require('./index')
+var imp = require('../../test/_js/testImports')
+
+var str1 = imp.data.str1
+var str2 = imp.data.str2
+
+describe('gitDiffFake', function() {
+
+  var sandbox
+
+  beforeEach(function() {
+    sandbox = imp.sinon.sandbox.create()
+    sandbox.spy(imp.color, 'add')
+  })
+
+  afterEach(function() {
+    sandbox.restore()
+  })
+
+  var testObjs = [{
+    testPrefix: 'line difference -',
+    wordDiff: false,
+    expected: imp.data.lineDiffFake,
+    oneLinerExpected: imp.data.oneLinerLineDiffFake,
+    endingsLinuxExpected: imp.data.endingsLinuxLineDiff,
+    endingsWindowsExpected: imp.data.endingsWindowsLineDiff
+  }, {
+    testPrefix: 'word difference -',
+    wordDiff: true,
+    expected: imp.data.wordDiffFake,
+    oneLinerExpected: imp.data.oneLinerWordDiffFake,
+    endingsLinuxExpected: imp.data.endingsLinuxWordDiff,
+    endingsWindowsExpected: imp.data.endingsWindowsWordDiff
+  }]
+
+  imp.using(testObjs, function() {
+
+    it('{testPrefix} color', function(testObj) {
+      var actual = gitDiffFake(str1, str2, {color: true, wordDiff: testObj.wordDiff})
+      imp.expect(actual).to.equal(testObj.expected)
+      imp.expect(imp.color.add).to.have.been.calledWith(imp.sinon.match.any, 'green')
+      imp.expect(imp.color.add).to.have.been.calledWith(imp.sinon.match.any, 'red')
+    })
+
+    it('{testPrefix} no color', function(testObj) {
+      var actual = gitDiffFake(str1, str2, {color: false, wordDiff: testObj.wordDiff})
+      imp.expect(actual).to.equal(testObj.expected)
+      imp.expect(imp.color.add).to.have.not.been.called
+    })
+
+    it('{testPrefix} one liner', function(testObj) {
+      var actual = gitDiffFake('my first string', 'my second string', {color: false, wordDiff: testObj.wordDiff})
+      imp.expect(actual).to.equal(testObj.oneLinerExpected)
+    })
+
+    it('{testPrefix} no difference', function(testObj) {
+      var actual = gitDiffFake('', '', {color: true, wordDiff: testObj.wordDiff})
+      imp.expect(actual).to.be.undefined
+      imp.expect(imp.color.add).to.have.not.been.called
+    })
+
+    it('{testPrefix} line endings', function(testObj) {
+      var actual
+
+      actual = gitDiffFake('my first\nstring', 'my second\nstring', {color: false, wordDiff: testObj.wordDiff})
+      imp.expect(actual).to.equal(testObj.endingsLinuxExpected)
+
+      actual = gitDiffFake('my first\r\nstring', 'my second\r\nstring', {color: false, wordDiff: testObj.wordDiff})
+      imp.expect(actual).to.equal(testObj.endingsWindowsExpected)
+    })
+  })
+})

package/examples/starter/node_modules/git-diff/js/gitDiffFake/lineDiffFake/index.js

@@ -0,0 +1,56 @@
+'use strict'
+
+var jsDiff = require('diff')
+var color = require('../color')
+var mostCommonLineEnding = require('../mostCommonLineEnding')
+
+function appendAllButLast(str, regex, append) {
+  var reg = new RegExp(regex, 'g')
+  return str.replace(reg, function(match, offset, str) {
+    var follow = str.slice(offset)
+    var isLast = follow.match(reg).length === 1
+    return (isLast) ? match : match + append
+  })
+}
+
+function lineDiffFake(str1, str2, options) {
+
+  var diff, isDiff, accumulatedDiff = ''
+
+  if (!CRE.test(str1) || !CRE.test(str2)) {
+    var mcle = mostCommonLineEnding(str1, str2)
+    str1 += mcle
+    str2 += mcle
+  }
+
+  diff = jsDiff.diffLines(str1, str2)
+
+  isDiff = diff.some(function(item) {
+    return item.added || item.removed
+  })
+
+  if (isDiff) {
+    diff.forEach(function(part) {
+      var culla, prefix
+      if (part.added) {
+        culla = 'green'
+        prefix = '+'
+      } else if (part.removed) {
+        culla = 'red'
+        prefix = '-'
+      } else {
+        culla = null
+        prefix = ' '
+      }
+      part.value = appendAllButLast(part.value, CRS, prefix)
+      part.diff = prefix + part.value
+      if (options.color && culla) part.diff = color.add(part.diff, culla)
+      accumulatedDiff += part.diff
+    })
+    return accumulatedDiff
+  }
+
+  return undefined
+}
+
+module.exports = lineDiffFake

package/examples/starter/node_modules/git-diff/js/gitDiffFake/mostCommonLineEnding.js

@@ -0,0 +1,21 @@
+'use strict'
+
+function mostCommonLineEnding(str1, str2) {
+
+  var str1Windows = str1.match(/\r\n/g)
+  var str2Windows = str2.match(/\r\n/g)
+  var str1Linux = str1.match(/\n/g)
+  var str2Linux = str2.match(/\n/g)
+
+  var str1WindowsCount = (str1Windows) ? str1Windows.length : 0
+  var str2WindowsCount = (str2Windows) ? str2Windows.length : 0
+  var str1LinuxCount = (str1Linux) ? str1Linux.length : 0
+  var str2LinuxCount = (str2Linux) ? str2Linux.length : 0
+
+  var windowsCount = str1WindowsCount + str2WindowsCount
+  var linuxCount = str1LinuxCount + str2LinuxCount - windowsCount
+
+  return (windowsCount > linuxCount) ? '\r\n' : '\n'
+}
+
+module.exports = mostCommonLineEnding

package/examples/starter/node_modules/git-diff/js/gitDiffFake/wordDiffFake/index.js

@@ -0,0 +1,44 @@
+'use strict'
+
+var jsDiff = require('diff')
+var color = require('../color')
+var mostCommonLineEnding = require('../mostCommonLineEnding')
+
+function wordDiffFake(str1, str2, options) {
+
+  var diff, isDiff, accumulatedDiff = ''
+
+  if (!CRE.test(str1) || !CRE.test(str2)) {
+    var mcle = mostCommonLineEnding(str1, str2)
+    str1 += mcle
+    str2 += mcle
+  }
+
+  diff = jsDiff.diffWordsWithSpace(str1, str2)
+
+  isDiff = diff.some(function(item) {
+    return item.added || item.removed
+  })
+
+  if (isDiff) {
+    diff.forEach(function(part) {
+      var culla
+      if (part.added) {
+        culla = 'green'
+        part.value = '{+' + part.value + '+}'
+      } else if (part.removed) {
+        culla = 'red'
+        part.value = '[-' + part.value + '-]'
+      } else {
+        culla = null
+      }
+      if (options.color && culla) part.value = color.add(part.value, culla)
+      accumulatedDiff += part.value
+    })
+    return accumulatedDiff
+  }
+
+  return undefined
+}
+
+module.exports = wordDiffFake

package/examples/starter/node_modules/git-diff/js/gitDiffReal/bugFixes.spec.js

@@ -0,0 +1,25 @@
+'use strict'
+
+var gitDiffReal = require('./index')
+var imp = require('../../test/_js/testImports')
+
+describe('gitDiffReal', function() {
+
+  beforeEach(function() {
+    delete require.cache[require.resolve('../_shared/defaultOptions')]
+    require('../_shared/defaultOptions')
+  })
+
+  describe('bug fixes', function() {
+
+    before(function() {
+      if (!imp.keepIt.real() && !imp.keepIt.realNoRepo()) this.skip()
+    })
+
+    it('Use of < in a string does not give cannot find the file specified', function() {
+      var expected = '@@ -1 +1 @@\n[-<a>-]{+<b>+}\n'
+      var actual = gitDiffReal('<a>', '<b>', {color: false, wordDiff: true})
+      imp.expect(actual).to.equal(expected)
+    })
+  })
+})

package/examples/starter/node_modules/git-diff/js/gitDiffReal/generateDiff/index.js

@@ -0,0 +1,105 @@
+'use strict'
+
+var exec = require('shelljs.exec')
+var logger = require('loglevel')
+var config = require('../../../config')
+
+var SHA_REGEX = /^[0-9a-fA-F]{5,}$/
+
+logger.setLevel('info')
+
+// Returns the same as:
+// git diff $(printf 'my first string' | git hash-object -w --stdin) $(printf 'my second string' | git hash-object -w --stdin) --word-diff
+// git diff $(printf 'This is a test for my diff tool\nIt is a big test\n\nNo diff here\n\nBut there might be here\nBut not here\n\nOr here\n' | git hash-object -w --stdin) $(printf 'This is a test for my difference tool\nIt is a small test\n\nNo diff here\n\nBut there might be here!\nBut not here\n\nOr here\n' | git hash-object -w --stdin) --word-diff
+
+function generateDiff(str1, str2, options, gitDir) {
+
+  var DEFAULTS = require('../../_shared/defaultOptions')
+
+  if (typeof gitDir === 'string') {
+    gitDir = '--git-dir ' + gitDir
+  } else {
+    gitDir = ''
+  }
+
+  // Single quotes is needed here to avoid .. event not found
+  var gitHashCmd1 = 'printf ' + JSON.stringify(str1) + ' | git ' + gitDir + ' hash-object -w --stdin'
+  var gitHashCmd2 = 'printf ' + JSON.stringify(str2) + ' | git ' + gitDir + ' hash-object -w --stdin'
+
+  var gitHashObj1 = exec(gitHashCmd1, {silent: true})
+  var gitHashObj2 = exec(gitHashCmd2, {silent: true})
+
+  /* istanbul ignore else */
+  if (gitHashObj1.code === 0 && gitHashObj2.code === 0) {
+
+    var sha1 = gitHashObj1.stdout.replace(CR, '')
+    var sha2 = gitHashObj2.stdout.replace(CR, '')
+
+    var sha1Test = SHA_REGEX.test(sha1)
+    var sha2Test = SHA_REGEX.test(sha2)
+
+    /* istanbul ignore else */
+    if (sha1Test && sha2Test) {
+
+      var diffObj, repeat
+
+      do {
+
+        var flags = ''
+
+        if (options.wordDiff) {
+          flags += ' --word-diff'
+        }
+
+        if (options.color) {
+          flags += ' --color=always'
+        }
+
+        if (options.flags) {
+          flags += ' ' + options.flags
+        }
+
+        var newCommand = 'git ' + gitDir + ' diff ' + sha1 + ' ' + sha2 + flags
+
+        diffObj = exec(newCommand, {silent: true})
+
+        if (diffObj.code === 129 && diffObj.stderr.indexOf('usage') > -1) {
+          logger.warn('Ignoring invalid git diff options: ' + options.flags)
+          logger.info('For valid git diff options refer to ' + config.gitDiffOptionsUrl)
+          if (options.flags === DEFAULTS.flags) {
+            DEFAULTS.flags = null
+          }
+          options.flags = DEFAULTS.flags
+          if (options.flags) {
+            logger.info('Using default git diff options: ' + options.flags)
+          }
+          repeat = true
+        } else {
+          repeat = false
+        }
+      } while (repeat)
+
+      /* istanbul ignore else */
+      if (diffObj.code === 0) {
+
+        var diff = diffObj.stdout
+        var atat = ATAT_REGEX.exec(diff)
+
+        if (atat) {
+          diff = diff.substring(atat.index)
+          if (options.noHeaders) {
+            diff = diff.replace(ATAT_REGEX, '')
+            diff = diff.replace(CR, '')
+          }
+        }
+
+        return (diff !== '') ? diff : undefined
+      }
+    }
+  }
+
+  /* istanbul ignore next */
+  return undefined
+}
+
+module.exports = generateDiff

package/examples/starter/node_modules/git-diff/js/gitDiffReal/generateDiffNoRepo/index.js

@@ -0,0 +1,27 @@
+'use strict'
+
+var exec = require('shelljs.exec')
+var generateDiff = require('../generateDiff')
+
+function generateDiffNoRepo(str1, str2, options) {
+
+  var tempDirObj = exec('mktemp -d', {silent: true})
+
+  /* istanbul ignore else */
+  if (tempDirObj.code === 0) {
+
+    var tempDir = tempDirObj.stdout.replace(CR, '')
+    var gitInitObj = exec('git init ' + tempDir, {silent: true})
+
+    /* istanbul ignore else */
+    if (gitInitObj.code === 0) {
+
+      return generateDiff(str1, str2, options, tempDir + '/.git')
+    }
+  }
+
+  /* istanbul ignore next */
+  return undefined
+}
+
+module.exports = generateDiffNoRepo

package/examples/starter/node_modules/git-diff/js/gitDiffReal/index.js

@@ -0,0 +1,16 @@
+'use strict'
+
+var generateDiff = require('./generateDiff')
+var generateDiffNoRepo = require('./generateDiffNoRepo')
+var keepIt = require('./keepIt')
+
+var gitDiffReal = function(str1, str2, options) {
+  if (keepIt.real()) {
+    return generateDiff(str1, str2, options)
+  } else if (keepIt.realNoRepo()) {
+    return generateDiffNoRepo(str1, str2, options)
+  }
+  return undefined
+}
+
+module.exports = gitDiffReal