* first action! (#1)

node_modules/from2/.travis.yml

@@ -0,0 +1,8 @@
+language: node_js
+before_install:
+  - npm install -g npm
+node_js:
+  - "0.8"
+  - "0.10"
+  - "0.12"
+  - "iojs"

node_modules/from2/LICENSE.md

@@ -0,0 +1,21 @@
+## The MIT License (MIT) ##
+
+Copyright (c) 2014 Hugh Kennedy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+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 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.

node_modules/from2/README.md

@@ -0,0 +1,70 @@
+# from2 [![Flattr this!](https://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=hughskennedy&url=http://github.com/hughsk/from2&title=from2&description=hughsk/from2%20on%20GitHub&language=en_GB&tags=flattr,github,javascript&category=software)[![experimental](http://hughsk.github.io/stability-badges/dist/experimental.svg)](http://github.com/hughsk/stability-badges) #
+
+`from2` is a high-level module for creating readable streams that properly handle backpressure.
+
+Convience wrapper for
+[readable-stream](http://github.com/isaacs/readable-stream)'s `ReadableStream`
+base class, with an API lifted from
+[from](http://github.com/dominictarr/from) and
+[through2](http://github.com/rvagg/through2).
+
+## Usage ##
+
+[![from2](https://nodei.co/npm/from2.png?mini=true)](https://nodei.co/npm/from2)
+
+### `stream = from2([opts], read)` ###
+
+Where `opts` are the options to pass on to the `ReadableStream` constructor,
+and `read(size, next)` is called when data is requested from the stream.
+
+* `size` is the recommended amount of data (in bytes) to retrieve.
+* `next(err)` should be called when you're ready to emit more data.
+
+For example, here's a readable stream that emits the contents of a given
+string:
+
+``` javascript
+var from = require('from2')
+
+function fromString(string) {
+  return from(function(size, next) {
+    // if there's no more content
+    // left in the string, close the stream.
+    if (string.length <= 0) return next(null, null)
+
+    // Pull in a new chunk of text,
+    // removing it from the string.
+    var chunk = string.slice(0, size)
+    string = string.slice(size)
+
+    // Emit "chunk" from the stream.
+    next(null, chunk)
+  })
+}
+
+// pipe "hello world" out
+// to stdout.
+fromString('hello world').pipe(process.stdout)
+```
+
+### `stream = from2.obj([opts], read)` ###
+
+Shorthand for `from2({ objectMode: true }, read)`.
+
+### `createStream = from2.ctor([opts], read)` ###
+
+If you're creating similar streams in quick succession you can improve
+performance by generating a stream **constructor** that you can reuse instead
+of creating one-off streams on each call.
+
+Takes the same options as `from2`, instead returning a constructor which you
+can use to create new streams.
+
+### See Also
+
+- [from2-array](https://github.com/binocarlos/from2-array) - Create a from2 stream based on an array of source values.
+- [from2-string](https://github.com/yoshuawuyts/from2-string) - Create a stream from a string. Sugary wrapper around from2.
+
+## License ##
+
+MIT. See [LICENSE.md](http://github.com/hughsk/from2/blob/master/LICENSE.md) for details.

node_modules/from2/index.js

@@ -0,0 +1,103 @@
+var Readable = require('readable-stream').Readable
+var inherits = require('inherits')
+
+module.exports = from2
+
+from2.ctor = ctor
+from2.obj = obj
+
+var Proto = ctor()
+
+function toFunction(list) {
+  list = list.slice()
+  return function (_, cb) {
+    var err = null
+    var item = list.length ? list.shift() : null
+    if (item instanceof Error) {
+      err = item
+      item = null
+    }
+
+    cb(err, item)
+  }
+}
+
+function from2(opts, read) {
+  if (typeof opts !== 'object' || Array.isArray(opts)) {
+    read = opts
+    opts = {}
+  }
+
+  var rs = new Proto(opts)
+  rs._from = Array.isArray(read) ? toFunction(read) : (read || noop)
+  return rs
+}
+
+function ctor(opts, read) {
+  if (typeof opts === 'function') {
+    read = opts
+    opts = {}
+  }
+
+  opts = defaults(opts)
+
+  inherits(Class, Readable)
+  function Class(override) {
+    if (!(this instanceof Class)) return new Class(override)
+    this._reading = false
+    this._callback = check
+    this.destroyed = false
+    Readable.call(this, override || opts)
+
+    var self = this
+    var hwm = this._readableState.highWaterMark
+
+    function check(err, data) {
+      if (self.destroyed) return
+      if (err) return self.destroy(err)
+      if (data === null) return self.push(null)
+      self._reading = false
+      if (self.push(data)) self._read(hwm)
+    }
+  }
+
+  Class.prototype._from = read || noop
+  Class.prototype._read = function(size) {
+    if (this._reading || this.destroyed) return
+    this._reading = true
+    this._from(size, this._callback)
+  }
+
+  Class.prototype.destroy = function(err) {
+    if (this.destroyed) return
+    this.destroyed = true
+
+    var self = this
+    process.nextTick(function() {
+      if (err) self.emit('error', err)
+      self.emit('close')
+    })
+  }
+
+  return Class
+}
+
+function obj(opts, read) {
+  if (typeof opts === 'function' || Array.isArray(opts)) {
+    read = opts
+    opts = {}
+  }
+
+  opts = defaults(opts)
+  opts.objectMode = true
+  opts.highWaterMark = 16
+
+  return from2(opts, read)
+}
+
+function noop () {}
+
+function defaults(opts) {
+  opts = opts || {}
+  return opts
+}

node_modules/from2/package.json

@@ -0,0 +1,69 @@
+{
+  "_from": "from2@^2.1.0",
+  "_id": "from2@2.3.0",
+  "_inBundle": false,
+  "_integrity": "sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=",
+  "_location": "/from2",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "from2@^2.1.0",
+    "name": "from2",
+    "escapedName": "from2",
+    "rawSpec": "^2.1.0",
+    "saveSpec": null,
+    "fetchSpec": "^2.1.0"
+  },
+  "_requiredBy": [
+    "/mississippi"
+  ],
+  "_resolved": "https://registry.npmjs.org/from2/-/from2-2.3.0.tgz",
+  "_shasum": "8bfb5502bde4a4d36cfdeea007fcca21d7e382af",
+  "_spec": "from2@^2.1.0",
+  "_where": "/home/shimataro/projects/actions/ssh-key-action/node_modules/mississippi",
+  "author": {
+    "name": "Hugh Kennedy",
+    "email": "hughskennedy@gmail.com",
+    "url": "http://hughsk.io/"
+  },
+  "bugs": {
+    "url": "https://github.com/hughsk/from2/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Mathias Buus",
+      "email": "mathiasbuus@gmail.com"
+    }
+  ],
+  "dependencies": {
+    "inherits": "^2.0.1",
+    "readable-stream": "^2.0.0"
+  },
+  "deprecated": false,
+  "description": "Convenience wrapper for ReadableStream, with an API lifted from \"from\" and \"through2\"",
+  "devDependencies": {
+    "tape": "^4.0.0"
+  },
+  "homepage": "https://github.com/hughsk/from2",
+  "keywords": [
+    "from",
+    "stream",
+    "readable",
+    "pull",
+    "convenience",
+    "wrapper"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "from2",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/hughsk/from2.git"
+  },
+  "scripts": {
+    "test": "node test"
+  },
+  "version": "2.3.0"
+}

node_modules/from2/test.js

@@ -0,0 +1,123 @@
+var test = require('tape')
+var path = require('path')
+var from = require('./')
+var fs   = require('fs')
+
+var tmp = path.resolve(
+  __dirname, 'tmp.txt'
+)
+
+function fromString(string) {
+  return from(function(size, next) {
+    if (string.length <= 0) return next(null, null)
+    var chunk = string.slice(0, size)
+    string = string.slice(size)
+    next(null, chunk)
+  })
+}
+
+test('from2', function(t) {
+  var contents = fs.readFileSync(__filename, 'utf8')
+  var stream = fromString(contents)
+
+  stream
+    .pipe(fs.createWriteStream(tmp))
+    .on('close', function() {
+      t.equal(fs.readFileSync(tmp, 'utf8'), contents)
+      fs.unlinkSync(tmp)
+      t.end()
+    })
+})
+
+test('old mode', function(t) {
+  var contents = fs.readFileSync(__filename, 'utf8')
+  var stream = fromString(contents)
+  var buffer = ''
+
+  stream.on('data', function(data) {
+    buffer += data
+  }).on('end', function() {
+    t.equal(buffer, contents)
+    t.end()
+  })
+})
+
+test('destroy', function(t) {
+  var stream = from(function(size, next) {
+    process.nextTick(function() {
+      next(null, 'no')
+    })
+  })
+
+  stream.on('data', function(data) {
+    t.ok(false)
+  }).on('close', function() {
+    t.ok(true)
+    t.end()
+  })
+
+  stream.destroy()
+})
+
+test('arrays', function (t) {
+  var input = ['a', 'b', 'c']
+  var stream = from(input)
+  var output = []
+  stream.on('data', function (letter) {
+    output.push(letter.toString())
+  })
+  stream.on('end', function () {
+    t.deepEqual(input, output)
+    t.end()
+  })
+})
+
+test('obj arrays', function (t) {
+  var input = [{foo:'a'}, {foo:'b'}, {foo:'c'}]
+  var stream = from.obj(input)
+  var output = []
+  stream.on('data', function (letter) {
+    output.push(letter)
+  })
+  stream.on('end', function () {
+    t.deepEqual(input, output)
+    t.end()
+  })
+})
+
+
+test('arrays can emit errors', function (t) {
+  var input = ['a', 'b', new Error('ooops'), 'c']
+  var stream = from(input)
+  var output = []
+  stream.on('data', function (letter) {
+    output.push(letter.toString())
+  })
+  stream.on('error', function(e){
+    t.deepEqual(['a', 'b'], output)
+    t.equal('ooops', e.message)
+    t.end()
+  })  
+  stream.on('end', function () {
+    t.fail('the stream should have errored')
+  })
+})
+
+test('obj arrays can emit errors', function (t) {
+  var input = [{foo:'a'}, {foo:'b'}, new Error('ooops'), {foo:'c'}]
+  var stream = from.obj(input)
+  var output = []
+  stream.on('data', function (letter) {
+    output.push(letter)
+  })
+  stream.on('error', function(e){
+    t.deepEqual([{foo:'a'}, {foo:'b'}], output)
+    t.equal('ooops', e.message)
+    t.end()
+  })
+  stream.on('end', function () {
+    t.fail('the stream should have errored')
+  })
+})
+
+