codingame-connector/lib/utils.js

An interface for Codingame website

'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _asyncGenerator2 = require('babel-runtime/helpers/asyncGenerator');

var _asyncGenerator3 = _interopRequireDefault(_asyncGenerator2);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _configure = require('./configure.js');

var _configure2 = _interopRequireDefault(_configure);

var _api = require('./codingame/api.js');

var _api2 = _interopRequireDefault(_api);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Display the error and kill the program
 *
 * @name kill
 * @function
 * @param {Error} error - The error that caused the problem
 * @memberof module:utils
 * @instance
 */
/**
 * @file Module 'utils'
 * @author woshilapin <woshilapin@tuziwo.info>
 */
/**
 * Some utils for Codingame's connector
 * @module utils
 */
var kill = function kill(error) {
	console.error('error: ' + error.message);
	process.exit(-1);
};

/**
 * Log in Codingame website
 *
 * @name login
 * @function
 * @param {number} tries - Number of tries before returning an error
 * @returns {Promise<Object>} The response from the server
 * @memberof module:utils
 * @instance
 */
var login = function login(tries) {
	if (tries === undefined || typeof tries !== 'number') {
		tries = 3;
	}
	var credentials = {};
	return _configure2.default.get('username', 'shell', 'login? ').then(function (username) {
		credentials.username = username;
		return _configure2.default.get('password', 'shell', 'password? ');
	}).then(function (password) {
		credentials.password = password;
		return _api2.default.login(credentials.username, credentials.password);
	}).then(function (res) {
		if (!res.error) {
			return _promise2.default.resolve(res);
		} else {
			tries -= 1;
			if (tries > 0) {
				console.warn('Unable to login (' + tries + ' ' + (tries > 1 ? 'tries' : 'try') + ' remaining).');
				_configure2.default.forget('username');
				_configure2.default.forget('password');
				return _promise2.default.resolve(login(tries));
			} else {
				return _promise2.default.reject(new Error('Unable to login.'));
			}
		}
	});
};

/**
 * Launch the test suite on Codingame
 *
 * @name tests
 * @function
 * @param {Object} parameters - Parameters defining the test to launch
 * @param {string} parameters.exercise - Hash of the exercise to test
 * @param {Array} parameters.tests - The list of test's numbers
 * @param {string} parameters.language - The language of the bundle to send
 * @param {string} parameters.bundle - Content of the program to send
 * @returns {Promise<Array>} All results; or in case of error, all results until error + the error as last element of the array
 * @memberof module:utils
 * @instance
 */
var tests = function () {
	var _ref = _asyncGenerator3.default.wrap(_regenerator2.default.mark(function _callee(_ref2) {
		var exercise = _ref2["exercise"],
		    tests = _ref2["tests"],
		    language = _ref2["language"],
		    bundle = _ref2["bundle"];

		var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, test;

		return _regenerator2.default.wrap(function _callee$(_context) {
			while (1) {
				switch (_context.prev = _context.next) {
					case 0:
						_iteratorNormalCompletion = true;
						_didIteratorError = false;
						_iteratorError = undefined;
						_context.prev = 3;
						_iterator = (0, _getIterator3.default)(tests);

					case 5:
						if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
							_context.next = 14;
							break;
						}

						test = _step.value;
						_context.next = 9;
						return _asyncGenerator3.default.await(_api2.default.test(exercise, test, language, bundle));

					case 9:
						_context.next = 11;
						return _context.sent;

					case 11:
						_iteratorNormalCompletion = true;
						_context.next = 5;
						break;

					case 14:
						_context.next = 20;
						break;

					case 16:
						_context.prev = 16;
						_context.t0 = _context['catch'](3);
						_didIteratorError = true;
						_iteratorError = _context.t0;

					case 20:
						_context.prev = 20;
						_context.prev = 21;

						if (!_iteratorNormalCompletion && _iterator.return) {
							_iterator.return();
						}

					case 23:
						_context.prev = 23;

						if (!_didIteratorError) {
							_context.next = 26;
							break;
						}

						throw _iteratorError;

					case 26:
						return _context.finish(23);

					case 27:
						return _context.finish(20);

					case 28:
					case 'end':
						return _context.stop();
				}
			}
		}, _callee, this, [[3, 16, 20, 28], [21,, 23, 27]]);
	}));

	function tests(_x) {
		return _ref.apply(this, arguments);
	}

	return tests;
}();

exports.default = {
	"kill": kill,
	"login": login,
	"tests": tests
};