actions/ssh-key-action
1
0
Fork 0
mirror of https://github.com/shimataro/ssh-key-action.git synced 2025-06-19 22:52:10 +10:00
Code Activity

* first action! (#1)

Browse source
This commit is contained in:
shimataro 2019-09-18 20:39:54 +09:00 • committed by GitHub
parent 8deacc95b1
commit ace1e6a69a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3750 changed files with 1155519 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

893
node_modules/cint/cint.js generated vendored Normal file
View file

@ -0,0 +1,893 @@
/** A Javascript utility belt with an emphasis on Functional Programming.
@module cint
@author Raine Lourie
@version v8.2.1 (Fri, 13 Feb 2015 20:24:14 GMT)
*/
cint = (function() {
'use strict';
/***********************************
* Private Functions
***********************************/
var _last = partialAt(index, 1, -1);
/***********************************
* String
***********************************/
/** Performs variable substitution on the string, replacing items in {curly braces}.
Same as Lodash's _.template(str, o, { interpolate: /{([\s\S]+?)}/g }).
Based on supplant by Douglas Crockford http://javascript.crockford.com/remedial.html
@memberOf module:cint#
@param {String} str
@param {Object|Array} o
*/
function supplant(str, o) {
return str.replace(/{([^{}]*)}/g,
function (a, b) {
return b in o ? o[b] : a
}
)
}
/** Returns true if the string starts with the given substring. Returns false if the substring is the empty string.
@memberOf module:cint#
@param {String} str
@param {String} sub The substring.
*/
function startsWith(str, sub){
return str.indexOf(sub) === 0 && sub !== ''
}
/** Returns the substring before the first instance of the given delimiter.
@memberOf module:cint#
@param {String} str
@param {String} delim
*/
function before(str, delim) {
return str.split(delim)[0]
}
/** Returns the substring after the first instance of the given delimiter. Returns the whole string if the delimiter is not found.
@memberOf module:cint#
@param {String} str
@param {String} delim
*/
function after(str, delim) {
var delimIndex = str.indexOf(delim)
return delimIndex >= 0 ?
str.substring(delimIndex+delim.length) : str
}
/** Returns the substring between the given delimiters.
@memberOf module:cint#
@param {String} str
@param {String} left
@param {String} right
*/
function between(str, left, right) {
return before(after(str, left), right)
}
/** Wraps a string with a left and right. If right omitted, wraps both ends in left.
@memberOf module:cint#
@param {string} middle
@param {string} left
@param {string} right
*/
function bookend(middle, left, right) {
return (left || '') + middle + (right || left || '')
}
/** Returns a single string that repeats the string n times. Optionally joins it with the given delimeter
@memberOf module:cint#
@param {String} str
@param {Number} n
@param {String} delim Default: ''
*/
function repeatString(str, n, delim) {
delim = delim || ''
return mapNumber(n, function() { return str }).join(delim)
}
/** Capitalizes the first letter of each word in the given string.
@memberOf module:cint#
@param {String} str
*/
function toTitleCase(str) {
var capitalizeFirst = function(s) {
return s.length ? s[0].toUpperCase() + s.substring(1).toLowerCase() : ''
}
return str.split(' ').map(capitalizeFirst).join(' ')
}
/***********************************
* Number
***********************************/
/** Returns the ordinal value (like '1st' or '2nd') of the given integer.
@memberOf module:cint#
@param {Number} n
*/
function ordinal(n) {
var lastDigit = n%10
return n + (
n >= 11 && n <= 13 ? 'th' :
lastDigit === 1 ? 'st' :
lastDigit === 2 ? 'nd' :
lastDigit === 3 ? 'rd' :
'th')
}
/** Invokes the given function n times, passing the index for each invocation, and returns an array of the results.
@memberOf module:cint#
@param {Number} n
@param {Function} f
*/
function mapNumber(n, f) {
var results = []
for(var i=0; i<n; i++) {
results.push(f(i))
}
return results
}
/** Adds two numbers. */
function addTwo(x, y) {
return x + y
}
/** Adds all given arguments. */
function add(/*x,y,z,...*/) {
return arguments.length ? Array.prototype.reduce.call(arguments, addTwo) : 0
}
/***********************************
* Array
***********************************/
/** Group the array of objects by one of the object's properties or mappable function. Returns an array of { key: ___, items: ___ } objects which represent all the items in the original array grouped by the value of the specified grouping key.
@memberOf module:cint#
@param {Object[]} arr
@param {String|Function} propOrFunc
*/
function orderedGroup(arr, propOrFunc) {
if(!propOrFunc) {
throw new Error('You must specific a property name or mappable function.')
}
var getGroupKey = typeof propOrFunc === 'function' ?
propOrFunc :
function(item) { return item[propOrFunc]; }
var results = []
var dict = {}
var len = arr.length
for(var i=0; i<len; i++) {
var key = getGroupKey(arr[i])
if(!(key in dict)) {
dict[key] = []
results.push({key: key, items: dict[key]})
}
dict[key].push(arr[i])
}
return results
}
/** Returns a dictionary whose keys are the values of the array and values are the number of instances of that value within the array.
@memberOf module:cint#
@param {Array} arr
*/
function tally(arr) {
var dict = {}
var len = arr.length
for(var i=0; i<len; i++) {
var count = dict[arr[i]] || 0
dict[arr[i]] = count + 1
}
return dict
}
/** Tally the property values of an array of object, grouping the counts for each property under its value.
e.g.
[
{
ideal: 4,
past: 3,
present: 7
},
{
ideal: 5,
past: 7,
present: 7
}
]
=>
{
"4": {
ideal: 1
},
"3": {
past: 1
}
"5": {
ideal: 1
}
"7": {
present: 2,
past: 1
}
}
*/
function tallyProps(arr) {
var tallies = {}
for(var i=0; i<arr.length; i++) {
var o = arr[i]
// loop through each property so the value can be tallied in the tallies object
for(var key in o) {
// cache the value
var value = o[key];
// create a new tally object if it doesn't exist for this value
if(!tallies[value]) {
tallies[value] = {}
}
// increment the count
tallies[value][key] = (tallies[value][key] || 0) + 1
}
}
return tallies
}
/** Returns the in-bounds index of the given index for the array, supports negative and out-of-bounds indices.
@private
@param {Array} arr
@param {Number} i
*/
function circ(arr, i) {
// return first index if i is null or undefined
if(i === undefined || i === null) {
return arr[0]
}
// one modulus to get in range, another to eliminate negative
return (i % arr.length + arr.length) % arr.length
}
/** Indexes into an array, supports negative indices.
@memberOf module:cint#
@param {Array} arr
@param {Number} n
*/
function index(arr, i) {
return arr[circ(arr, i)]
}
/** Returns a new array containing the elements of the given array shifted n spaces to the left, wrapping around the end.
@memberOf module:cint#
@param {Array} arr
@param {Number} n
*/
function rotate(arr, n) {
var output = []
var len = arr.length
for(var i=0; i<len; i++) {
output.push(index(arr, i+n))
}
return output
}
/** Creates an object with a property for each element of the given array, determined by a function that returns the property as a { key: value }.
@memberOf module:cint#
@param {Array} arr
@param {Function} f
*/
function toObject(arr, f) {
var keyValues = []
var len = arr.length
for(var i=0; i<len; i++) {
keyValues.push(f(arr[i], i))
}
return merge.apply(arr, keyValues)
}
/** Functional, nondestructive version of Array.prototype.splice.
@memberOf module:cint#
@param {Array} arr
@param {Number} index
@param {Number} howMany
@param {...*} elements
*/
function spliced(arr, index, howMany/*, elements*/) {
var elements = Array.prototype.slice.apply(arguments, [3])
var elementsLen = elements.length
var results = []
var len = arr.length
// add starting elements
for(var i=0; i<index && i<len; i++) {
results.push(arr[i])
}
// add inserted elements
for(i=0; i<elementsLen; i++) {
results.push(elements[i])
}
// add ending elements
for(i=index+howMany; i<len; i++) {
results.push(arr[i])
}
return results
}
/** Breaks up the array into n evenly-sized chunks.
Solution from http://stackoverflow.com/questions/8188548/splitting-a-js-array-into-n-arrays
@memberOf module:cint#
@param {Array} arr
@param {Number} n
*/
function chunk(a, n) {
var len = a.length,out = [], i = 0
while (i < len) {
var size = Math.ceil((len - i) / n--)
out.push(a.slice(i, i += size))
}
return out
}
/***********************************
* Object
***********************************/
/** Returns a new object with the given key and value.
@memberOf module:cint#
@param {String} key
@param value
*/
function keyValue(key, value) {
var o = {}
o[key] = value
return o
}
/** Gets the value of a key of the given object.
*/
function getValue(o, key) {
return o[key];
}
/** Sets the value of the given key and returns the object.
*/
function setValue(o, key, value) {
o[key] = value
return o
}
/** Creates a mapping function that applies the given function to the value of the specified key.
*/
function mapOverKey(f, originalKey, newKey) {
return function(o) {
return setValue(o, newKey || originalKey, f(o[originalKey]))
}
}
/** Join the object into a single string with the given separators separating properties from each other as well as values.
@memberOf module:cint#
@param {Object} obj
@param {String} propSeparator
@param {String} valueSeparator
*/
function joinObject(obj, propSeparator, valueSeparator) {
var keyValuePairs = []
for(var prop in obj) {
keyValuePairs.push(prop + valueSeparator + obj[prop])
}
return keyValuePairs.join(propSeparator)
}
/** Returns a new object with the given objects merged onto it. Non-undefined properties on later arguments override identical properties on earlier arguments.
@memberOf module:cint#
@param {...Object} objects
*/
function merge(/*obj1, obj2, obj3, ...*/) {
var mothership = {}
// iterate through each given object
var len = arguments.length
for(var i=0; i<len; i++) {
var outlier = arguments[i]
// add each property to the mothership
for(var prop in outlier) {
if(typeOf(outlier[prop]) === 'object' && outlier[prop].constructor === Object && outlier[prop] !== null && !(outlier[prop] instanceof Array)) {
mothership[prop] = merge(mothership[prop], outlier[prop]) // RECURSION
}
else if(outlier[prop] !== undefined) {
mothership[prop] = outlier[prop]
}
}
}
return mothership
}
/** Returns a new object where f(key, value) returns a new key-value pair for each property.
@memberOf module:cint#
@param {Object} obj
@param {Function} f
*/
function mapObject(obj, f) {
var result = {}
for(var key in obj) {
var pair = f(key, obj[key])
for(var prop in pair) {
result[prop] = pair[prop]
}
}
return result
}
/** Returns an array whose items are the result of calling f(key, value) on each property of the given object. If f is undefined, returns a list of { key: ___, value: ___ } objects.
@memberOf module:cint#
@param {Object} obj
@param {Function} f
*/
function toArray(obj, f) {
f = f || function(key, value) { return { key: key, value: value } }
var result = []
for(var key in obj) {
result.push(f(key, obj[key]))
}
return result
}
/** Returns a new object that only includes the properties of the given obj for which f(key, value) is true.
@memberOf module:cint#
@param {Object} obj
@param {Function} f
*/
function filterObject(obj, f) {
var result = {}
for(var key in obj) {
if(f(key, obj[key])) {
result[key] = obj[key]
}
}
return result
}
/** Changes the specified keys in an object.
@param {Object} obj
@param {Object} changeKeys
@example cint.changeKeys(
{ fname: 'Raine', lname: 'Lourie', specialty: 'Javascript' },
{ fname: 'first', lname: 'last' }
)
*/
function changeKeys(obj, changedKeys) {
var result = {}
for(var key in obj) {
result[key in changedKeys ? changedKeys[key] : key] = obj[key]
}
return result
}
/** Calls a function on an object and returns the object (for chaining purposes).
*/
function tap(f, o) {
f(o)
return o
}
/* console.log's the given object and returns the object (for chaining purposes).
*/
function look(o) {
console.log(o)
return o
}
/***********************************
* Function
***********************************/
/** Returns a function that returns the inverse of the given boolean function.
@memberOf module:cint#
@param {function} f The function to inverse.
*/
function not(f) {
return function() {
return !f.apply(this, arguments)
}
}
/** Returns a new function that inserts the given curried arguments to the inner function at the specified index of its runtime arguments.
@memberOf module:cint#
@example _.partial(f, args...) is equivalent to cint.partialAt(f, 0, args) and _.partialRight(f, args...) is equivalent to cint.partialAt(f, n, args) where n is the arity of the function.
@param {Function} f
@param {Number} index
@param {...*} curriedArgs
*/
function partialAt(f, index, curriedArgs) {
return function() {
var givenArgs = Array.prototype.slice.call(arguments)
// handle negative indices
// Note that we add 1 so that -1 points to the slot AFTER the last element, not before the last element (which is what the last index points to).
if(index < 0) {
index = circ(givenArgs, index) + 1
}
var spliceArgs = [givenArgs, index, 0].concat(curriedArgs)
var newArgs = spliced.apply(this, spliceArgs)
return f.apply(this, newArgs)
}
}
/** Returns a new function that calls the given function with a limit on the number of arguments.
@memberOf module:cint#
@param {Function} f
@param {Number} n
*/
function aritize(f, n) {
return function() {
var givenArgs = Array.prototype.slice.call(arguments, 0, n)
return f.apply(this, givenArgs)
}
}
/** Recursively invokes the given function with no parameters until it returns a non-functional value.
@memberOf module:cint#
@param value
*/
function callTillValue(value) {
return typeof value === 'function' ? callTillValue(value()) : value
}
/** Returns a function that calls the given function as normal, then passes its inputs and output to the spier (defaults to console.log)
@memberOf module:cint#
@param {Function} f
@param {Function} [spier=console.log]
*/
function spy(f, spier) {
var that = this
/* jshint ignore:start */
spier = spier || console.log.bind(console)
/* jshint ignore:end */
return function() {
var args = Array.prototype.slice.call(arguments)
var out = f.apply(that, args)
spier.call(that, f, args, out)
return out
}
}
/** Returns a copy of the given function that calls the original function in the context of the first argument. Passes arguments 1..n as normal.
@memberOf module:cint#
@param f
*/
function inContext(f) {
return function(context) {
var otherArgs = Array.prototype.slice.call(arguments, 1)
return f.apply(context, otherArgs)
}
}
/** Converts the given synchronous function into an asynchronous function that applies its arguments to the original function and invokes callback(error, result).
@memberOf module:cint#
@param f
*/
function toAsync(f) {
return function(/* [arg1], [arg2], ..., callback */) {
var that = this;
var args = Array.prototype.slice.call(arguments);
var callback = _last(args);
setTimeout(function() {
try {
var result = f.apply(that, args);
callback(null, result);
}
catch(e) {
callback(e);
}
}, 0)
};
}
/***********************************
* Utility
***********************************/
/** Compares two items lexigraphically. Returns 1 if a>b, 0 if a==b, or -1 if a<b.
@memberOf module:cint#
@param a
@param b
*/
function compare(a,b) {
return a > b ? 1 :
a < b ? -1 :
0
}
/** Compares the value of the given property between two objects.
@memberOf module:cint#
@param {String} property
*/
function compareProperty(property, a, b) {
return compare(a[property], b[property])
}
/** Returns a compare function that can be passed to Array.sort to sort in the order of the given array of properties. A property can also be appended with ' ASC' or ' DESC' to control the sort order.
@memberOf module:cint#
@param {String[]|Object[]} props
*/
function dynamicCompare(props) {
if(!props || !(props instanceof Array)) {
throw new Error('props is falsey or not an Array')
}
return function(a,b) {
var len = props.length
for(var i=0; i<len; i++) {
var aVal, bVal, sortDir
if(typeof props[i] == 'function') {
aVal = props[i](a)
bVal = props[i](b)
sortDir = 'asc'
}
else if(props[i].toLowerCase().indexOf(' ') >= 0) {
var splitVal = props[i].split(' ')
aVal = a[splitVal[0]]
bVal = b[splitVal[0]]
sortDir = splitVal[1].toLowerCase()
}
else {
aVal = a[props[i]]
bVal = b[props[i]]
sortDir = 'asc'
}
// this is important so that if the values are equial, it continues to the next sort property
if(aVal != bVal) {
return sortDir == 'asc' ? compare(aVal,bVal) : compare(bVal,aVal)
}
}
return 0
}
}
/** Returns true if all the items in a are equal to all the items in b, recursively.
@memberOf module:cint#
@param a
@param b
*/
function equals(a,b) {
if(typeof a !== typeof b) {
return false
}
// compare arrays
if(a instanceof Array) {
// check if the arrays are the same length
if(a.length !== b.length) {
return false
}
// check the equality of each item
for(var i=0, l=a.length; i<l; i++) {
if(!b || !b[i] || !equals(a[i], b[i])) { // RECURSION
return false
}
}
}
// compare primitives
else if(typeof a === 'number' || typeof a === 'string' || typeof a === 'boolean' || typeof a === 'undefined') {
if(a !== b) {
return false
}
}
// compare objects
else if(Object.keys(a).length === Object.keys(b)) {
for(var property in a) {
if(!(property in b && b[property] === a[property])) {
return false
}
}
}
else {
return a === b
}
return true
}
/** Returns true if the given value is not undefined, null, or an empty string.
@memberOf module:cint#
@param x
*/
function isValue(x) {
return x !== undefined && x !== null && x !== ''
}
/** Returns a string representation of the given scalar, array, or dictionary.
@memberOf module:cint#
@param o
*/
function hash(o) {
if(o === undefined) {
return 'undefined'
}
else if(o === null) {
return 'null'
}
else if(typeof o === 'string' || typeof o === 'number') {
return '' + o
}
else if(typeOf(o) === 'array') {
return '_[{0}]_'.format(o.map(hash).join(','))
}
else if(typeOf(o) === 'object') {
var objString = ''
for(var prop in o) {
objString += supplant('{0}_:_{1}', [prop, hash(o[prop])])
}
// escape for handlebars
return supplant('_\{{0}}_', [objString]) // jshint ignore:line
}
else {
throw new Error('Unhashable value: ' + o)
}
}
/** Generates a pseudo-random string that can be assumed to be unique. */
var guid = (function() {
var S4 = function() {
return (((1+Math.random())*0x10000)|0).toString(16).substring(1)
}
return function() {
return S4()+S4()+'-'+S4()+'-'+S4()+'-'+S4()+'-'+S4()+S4()+S4()
}
})()
/** Returns a string representing the type of the object, with special handling for null and arrays.
@author Douglas Crockford http://javascript.crockford.com/remedial.html
@param value
*/
function typeOf(value) {
var s = typeof value
if (s === 'object') {
if (value) {
if (typeof value.length === 'number' &&
!(value.propertyIsEnumerable('length')) &&
typeof value.splice === 'function') {
s = 'array'
}
} else {
s = 'null'
}
}
return s
}
/** Create a new instance of the given constructor with the given constructor arguments. Useful for higher order programmer where the new keyword won't work.
@memberOf module:cint#
@param {Function} C Constructor
@param {Array} args
*/
function createNew(C, args) {
var o = new C()
C.apply(o, args)
return o
}
/** Converts the given value to a string by calling its toString method.
*/
function intoString(value) {
return value.toString()
}
/***********************************
* Export Public Interface
***********************************/
return {
// string
supplant : supplant,
startsWith : startsWith,
before : before,
after : after,
between : between,
bookend : bookend,
repeatString : repeatString,
toTitleCase : toTitleCase,
// number
ordinal : ordinal,
mapNumber : mapNumber,
addTwo : addTwo,
add : add,
// array
orderedGroup : orderedGroup,
tally : tally,
tallyProps : tallyProps,
index : index,
rotate : rotate,
toObject : toObject,
spliced : spliced,
chunk : chunk,
// object
keyValue : keyValue,
getValue : getValue,
setValue : setValue,
mapOverKey : mapOverKey,
joinObject : joinObject,
mapObject : mapObject,
toArray : toArray,
filterObject : filterObject,
changeKeys : changeKeys,
tap : tap,
look : look,
// function
not : not,
partialAt : partialAt,
aritize : aritize,
callTillValue : callTillValue,
spy : spy,
inContext : inContext,
toAsync : toAsync,
// utility
compare : compare,
compareProperty : compareProperty,
dynamicCompare : dynamicCompare,
equals : equals,
isValue : isValue,
hash : hash,
guid : guid,
typeOf : typeOf,
'new' : createNew,
intoString : intoString
}
})()
// requirejs export
if(typeof module !== 'undefined') {
module.exports = cint
}