Upgrade to gulp 4; remove http server (#1030)

* Update gulp version to ^4.0.2 and Gulpfile.js

* Remove http server

Gulpfile.js

@@ -6,15 +6,12 @@ const fs = require('fs');
 const path = require('path');
 const assert = require('assert');
 const gulp = require('gulp');
-const rename = require('gulp-rename');
 const webpack = require('webpack');
-const bump = require('gulp-bump');
-const argv = require('yargs').argv;
-const UglifyJsPlugin = require('uglifyjs-webpack-plugin')
+const UglifyJsPlugin = require('uglifyjs-webpack-plugin');
 
-var pkg = require('./package.json');
+const pkg = require('./package.json');
 
-var uglifyOptions = {
+const uglifyOptions = {
   mangle: {
     reserved: ['_', 'RippleError', 'RippledError', 'UnexpectedError',
     'LedgerVersionError', 'ConnectionError', 'NotConnectedError',
@@ -36,7 +33,7 @@ function getWebpackConfig(extension, overrides) {
     output: {
       library: 'ripple',
       path: path.join(__dirname, 'build/'),
-      filename: ['ripple-', extension].join(pkg.version)
+      filename: `ripple-${pkg.version}${extension}`
     },
     plugins: [
       new webpack.NormalModuleReplacementPlugin(/^ws$/, './wswrapper'),
@@ -69,7 +66,7 @@ function getWebpackConfig(extension, overrides) {
   return _.assign({}, defaults, overrides);
 }
 
-function webpackConfigForWebTest(testFileName, path) {
+function webpackConfigForWebTest(testFileName) {
   var match = testFileName.match(/\/?([^\/]*)-test.js$/);
   if (!match) {
     assert(false, 'wrong filename:' + testFileName);
@@ -83,28 +80,13 @@ function webpackConfigForWebTest(testFileName, path) {
     entry: testFileName,
     output: {
       library: match[1].replace(/-/g, '_'),
-      path: './test-compiled-for-web/' + (path ? path : ''),
+      path: path.join(__dirname, 'test-compiled-for-web/'),
       filename: match[1] + '-test.js'
     }
   };
   return getWebpackConfig('.js', configOverrides);
 }
 
-gulp.task('build-tests', function(callback) {
-  var times = 0;
-  function done() {
-    if (++times >= 5) {
-      callback();
-    }
-  }
-  webpack(webpackConfigForWebTest('./test/rangeset-test.js'), done);
-  webpack(webpackConfigForWebTest('./test/connection-test.js'), done);
-  webpack(webpackConfigForWebTest('./test/api-test.js'), done);
-  webpack(webpackConfigForWebTest('./test/broadcast-api-test.js'), done);
-  webpack(webpackConfigForWebTest('./test/integration/integration-test.js',
-    'integration/'), done);
-});
-
 function createLink(from, to) {
   if (fs.existsSync(to)) {
     fs.unlinkSync(to);
@@ -120,11 +102,22 @@ function createBuildLink(callback) {
   };
 }
 
-gulp.task('build', function(callback) {
-  webpack(getWebpackConfig('.js'), createBuildLink(callback));
-});
+function watch(callback) {
+  gulp.watch('src/*', gulp.series(buildDebug));
+  callback();
+}
 
-gulp.task('build-min', function(callback) {
+function build(callback) {
+  webpack(getWebpackConfig('.js'), createBuildLink(callback));
+}
+
+function buildDebug(callback) {
+  const webpackConfig = getWebpackConfig('-debug.js', {devtool: 'eval'});
+  webpackConfig.plugins.unshift(new webpack.LoaderOptionsPlugin({debug: true}));
+  webpack(webpackConfig, callback);
+}
+
+function buildMin(callback) {
   const webpackConfig = getWebpackConfig('-min.js');
   webpackConfig.plugins.push(new UglifyJsPlugin({uglifyOptions}));
   webpack(webpackConfig, function() {
@@ -132,86 +125,27 @@ gulp.task('build-min', function(callback) {
       './build/ripple-latest-min.js');
     callback();
   });
-});
-
-gulp.task('build-debug', function(callback) {
-  const webpackConfig = getWebpackConfig('-debug.js', {devtool: 'eval'});
-  webpackConfig.plugins.unshift(new webpack.LoaderOptionsPlugin({debug: true}));
-  webpack(webpackConfig, callback);
-});
-
-/**
- * Generate a WebPack external for a given unavailable module which replaces
- * that module's constructor with an error-thrower
- */
-function buildUseError(cons) {
-  return ('var {<CONS>:function(){throw new Error('
-          + '"Class is unavailable in this build: <CONS>")}}')
-          .replace(new RegExp('<CONS>', 'g'), cons);
 }
 
-gulp.task('build-core', function(callback) {
-  var configOverrides = {
-    cache: false,
-    entry: './src/remote.ts',
-    externals: [{
-      './transaction': buildUseError('Transaction'),
-      './orderbook': buildUseError('OrderBook'),
-      './account': buildUseError('Account'),
-      './serializedobject': buildUseError('SerializedObject')
-    }],
-    plugins: [
-      new UglifyJsPlugin()
-    ]
-  };
-  webpack(getWebpackConfig('-core.js', configOverrides), callback);
-});
-
-gulp.task('bower-build', ['build'], function() {
-  return gulp.src(['./build/ripple-', '.js'].join(pkg.version))
-  .pipe(rename('ripple.js'))
-  .pipe(gulp.dest('./dist/bower'));
-});
-
-gulp.task('bower-build-min', ['build-min'], function() {
-  return gulp.src(['./build/ripple-', '-min.js'].join(pkg.version))
-  .pipe(rename('ripple-min.js'))
-  .pipe(gulp.dest('./dist/bower'));
-});
-
-gulp.task('bower-build-debug', ['build-debug'], function() {
-  return gulp.src(['./build/ripple-', '-debug.js'].join(pkg.version))
-  .pipe(rename('ripple-debug.js'))
-  .pipe(gulp.dest('./dist/bower'));
-});
-
-gulp.task('bower-version', function() {
-  gulp.src('./dist/bower/bower.json')
-  .pipe(bump({version: pkg.version}))
-  .pipe(gulp.dest('./dist/bower'));
-});
-
-gulp.task('bower', ['bower-build', 'bower-build-min', 'bower-build-debug',
-                    'bower-version']);
-
-gulp.task('watch', function() {
-  gulp.watch('src/*', ['build-debug']);
-});
-
-gulp.task('version-bump', function() {
-  if (!argv.type) {
-    throw new Error('No type found, pass it in using the --type argument');
+function buildTests(callback) {
+  var times = 0;
+  function done() {
+    if (++times >= 5) {
+      callback();
+    }
   }
+  webpack(webpackConfigForWebTest('./test/rangeset-test.js'), done);
+  webpack(webpackConfigForWebTest('./test/connection-test.js'), done);
+  webpack(webpackConfigForWebTest('./test/api-test.js'), done);
+  webpack(webpackConfigForWebTest('./test/broadcast-api-test.js'), done);
+  webpack(webpackConfigForWebTest('./test/integration/integration-test.js',
+    'integration/'), done);
+}
 
-  gulp.src('./package.json')
-  .pipe(bump({type: argv.type}))
-  .pipe(gulp.dest('./'));
-});
+exports.watch = watch;
+exports.build = build;
+exports.buildDebug = buildDebug;
+exports.buildMin = buildMin;
+exports.buildTests = buildTests;
 
-gulp.task('version-beta', function() {
-  gulp.src('./package.json')
-  .pipe(bump({version: pkg.version + '-beta'}))
-  .pipe(gulp.dest('./'));
-});
-
-gulp.task('default', ['build', 'build-debug', 'build-min']);
+exports.default = gulp.parallel(build, buildDebug, buildMin);

package.json

@@ -36,10 +36,7 @@
     "doctoc": "^0.15.0",
     "ejs": "^2.3.4",
     "eventemitter2": "^0.4.14",
-    "gulp": "^3.8.10",
-    "gulp-bump": "^0.1.13",
-    "gulp-rename": "^1.2.0",
-    "jayson": "^1.2.2",
+    "gulp": "^4.0.2",
     "json-loader": "^0.5.2",
     "json-schema-to-markdown-table": "^0.4.0",
     "mocha": "6.1.3",
@@ -53,8 +50,7 @@
     "tslint-eslint-rules": "^4.1.1",
     "typescript": "3.4.2",
     "uglifyjs-webpack-plugin": "^1.1.4",
-    "webpack": "3.12.0",
-    "yargs": "13.2.2"
+    "webpack": "3.12.0"
   },
   "scripts": {
     "build": "gulp",
@@ -67,8 +63,7 @@
     "test": "TS_NODE_PROJECT=src/tsconfig.json nyc mocha --exit",
     "lint": "tslint -p ./",
     "perf": "./scripts/perf_test.sh",
-    "start": "node scripts/http.js",
-    "sauce": "node scripts/sauce-runner.js"
+    "start": "node scripts/http.js"
   },
   "repository": {
     "type": "git",

scripts/ci.sh

@@ -45,7 +45,6 @@ unittest() {
 
 integrationtest() {
   mocha test/integration/integration-test.js
-  mocha test/integration/http-integration-test.js
 
   # run integration tests in PhantomJS
   #gulp build-tests build-min

scripts/http.js

@@ -1,16 +0,0 @@
-'use strict';
-
-const createHTTPServer = require('../dist/npm/http').createHTTPServer;
-const port = 5990;
-const serverUrl = 'wss://s1.ripple.com';
-
-
-function main() {
-  const server = createHTTPServer({server: serverUrl}, port);
-  server.start().then(() => {
-    console.log('Server started on port ' + String(port));
-  });
-}
-
-
-main();

src/http.ts

@@ -1,84 +0,0 @@
-/* eslint-disable new-cap */
-
-import * as assert from 'assert'
-import * as _ from 'lodash'
-import * as jayson from 'jayson'
-import {RippleAPI} from './api'
-
-
-/* istanbul ignore next */
-function createHTTPServer(options, httpPort) {
-  const rippleAPI = new RippleAPI(options)
-
-  const methodNames = _.filter(_.keys(RippleAPI.prototype), k => {
-    return typeof RippleAPI.prototype[k] === 'function'
-    && k !== 'connect'
-    && k !== 'disconnect'
-    && k !== 'constructor'
-    && k !== 'RippleAPI'
-  })
-
-  function applyPromiseWithCallback(fnName, callback, args_) {
-    try {
-      let args = args_
-      if (!_.isArray(args_)) {
-        const fnParameters = jayson.Utils.getParameterNames(rippleAPI[fnName])
-        args = fnParameters.map(name => args_[name])
-        const defaultArgs = _.omit(args_, fnParameters)
-        assert(_.size(defaultArgs) <= 1,
-          'Function must have no more than one default argument')
-        if (_.size(defaultArgs) > 0) {
-          args.push(defaultArgs[_.keys(defaultArgs)[0]])
-        }
-      }
-      Promise.resolve(rippleAPI[fnName](...args))
-        .then(res => callback(null, res))
-        .catch(err => {
-          callback({code: 99, message: err.message, data: {name: err.name}})
-        })
-    } catch (err) {
-      callback({code: 99, message: err.message, data: {name: err.name}})
-    }
-  }
-
-  const methods = {}
-  _.forEach(methodNames, fn => {
-    methods[fn] = jayson.Method((args, cb) => {
-      applyPromiseWithCallback(fn, cb, args)
-    }, {collect: true})
-  })
-
-  const server = jayson.server(methods)
-  let httpServer = null
-
-  return {
-    server: server,
-    start: function() {
-      if (httpServer !== null) {
-        return Promise.reject('Already started')
-      }
-      return new Promise(resolve => {
-        rippleAPI.connect().then(() => {
-          httpServer = server.http()
-          httpServer.listen(httpPort, resolve)
-        })
-      })
-    },
-    stop: function() {
-      if (httpServer === null) {
-        return Promise.reject('Not started')
-      }
-      return new Promise(resolve => {
-        rippleAPI.disconnect()
-        httpServer.close(() => {
-          httpServer = null
-          resolve()
-        })
-      })
-    }
-  }
-}
-
-export {
-  createHTTPServer
-}

test/integration/http-integration-test.js

@@ -1,202 +0,0 @@
-/* eslint-disable max-nested-callbacks */
-'use strict';
-const assert = require('assert-diff');
-const _ = require('lodash');
-const jayson = require('jayson');
-
-const RippleAPI = require('../../src').RippleAPI;
-const createHTTPServer = require('../../src/http').createHTTPServer;
-const {payTo, ledgerAccept} = require('./utils');
-
-const apiFixtures = require('../fixtures');
-const apiRequests = apiFixtures.requests;
-const apiResponses = apiFixtures.responses;
-
-const TIMEOUT = 20000;   // how long before each test case times out
-
-const serverUri = 'ws://127.0.0.1:6006';
-const apiOptions = {
-  server: serverUri
-};
-
-const httpPort = 3000;
-
-function createClient() {
-  return jayson.client.http({port: httpPort, hostname: 'localhost'});
-}
-
-const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
-
-function makePositionalParams(params) {
-  return params.map(value => value[_.keys(value)[0]]);
-}
-
-function makeNamedParams(params) {
-  return _.reduce(params, _.assign, {});
-}
-
-function random() {
-  return _.fill(Array(16), 0);
-}
-
-
-describe('http server integration tests', function() {
-  this.timeout(TIMEOUT);
-
-  let server = null;
-  let client = null;
-  let paymentId = null;
-  let newWallet = null;
-
-  function createTestInternal(testName, methodName, params, testFunc, id) {
-    it(testName, function() {
-      return new Promise((resolve, reject) => {
-        client.request(methodName, params, id,
-          (err, result) => err ? reject(err) : resolve(testFunc(result)));
-      });
-    });
-  }
-
-  function createTest(name, params, testFunc, id) {
-    createTestInternal(name + ' - positional params', name,
-      makePositionalParams(params), testFunc, id);
-    createTestInternal(name + ' - named params', name,
-      makeNamedParams(params), testFunc, id);
-  }
-
-  before(() => {
-    this.api = new RippleAPI({server: serverUri});
-    console.log('CONNECTING...');
-    return this.api.connect().then(() => {
-      console.log('CONNECTED...');
-    })
-    .then(() => ledgerAccept(this.api))
-    .then(() => newWallet = this.api.generateAddress())
-    .then(() => ledgerAccept(this.api))
-    .then(() => payTo(this.api, newWallet.address))
-    .then(paymentId_ => {
-      paymentId = paymentId_;
-    });
-  });
-
-  beforeEach(function() {
-    server = createHTTPServer(apiOptions, httpPort);
-    return server.start().then(() => {
-      this.client = createClient();
-      client = this.client;
-    });
-  });
-
-  afterEach(function() {
-    return server.stop();
-  });
-
-
-  createTest(
-    'getLedgerVersion',
-    [],
-    result => assert(_.isNumber(result.result))
-  );
-
-  createTest(
-    'getServerInfo',
-    [],
-    result => assert(_.isNumber(result.result.validatedLedger.ledgerVersion))
-  );
-
-  it('getTransaction', function() {
-    const params = [{id: paymentId}];
-    return new Promise((resolve, reject) => {
-      client.request('getTransaction', makePositionalParams(params),
-        (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          assert.strictEqual(result.result.id, paymentId);
-          const outcome = result.result.outcome;
-          assert.strictEqual(outcome.result, 'tesSUCCESS');
-          assert.strictEqual(outcome.balanceChanges
-            .rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh[0].value, '-4003218.000012');
-          resolve(result);
-        });
-    });
-  });
-
-  it('getTransactions', function() {
-    const params = [{address: newWallet.address}, {
-      options: {
-        binary: true,
-        limit: 1
-      }
-    }];
-    return new Promise((resolve, reject) => {
-      client.request('getTransactions', makeNamedParams(params),
-        (err, result) => {
-          if (err) {
-            reject(err);
-          }
-          assert.strictEqual(result.result.length, 1);
-          assert.strictEqual(result.result[0].id, paymentId);
-          resolve(result);
-        });
-    });
-  });
-
-  createTest(
-    'prepareSettings',
-    [
-      {address},
-      {settings: apiRequests.prepareSettings.domain},
-      {instructions: {
-        maxFee: '0.000012',
-        sequence: 23,
-        maxLedgerVersion: 8820051
-      }}
-    ],
-    result => {
-      const got = JSON.parse(result.result.txJSON);
-      const expected = JSON.parse(apiResponses.prepareSettings.flags.txJSON);
-      assert.deepEqual(got, expected);
-    }
-  );
-
-  createTest(
-    'sign',
-    [{txJSON: apiRequests.sign.normal.txJSON},
-    {secret: 'shsWGZcmZz6YsWWmcnpfr6fLTdtFV'}],
-    result => assert.deepEqual(result.result, apiResponses.sign.normal)
-  );
-
-  createTest(
-    'sign',
-    [{txJSON: apiRequests.sign.normal.txJSON},
-    {keypair: {
-      privateKey: '00ACCD3309DB14D1A4FC9B1DAE608031F4408C85C73EE05E035B7DC8B25840107A',
-      publicKey: '02F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D8' }}],
-    result => assert.deepEqual(result.result, apiResponses.sign.normal)
-  );
-
-  createTest(
-    'generateAddress',
-    [{options: {entropy: random()}}],
-    result => assert.deepEqual(result.result, apiResponses.generateAddress)
-  );
-
-  createTest(
-    'computeLedgerHash',
-    [{ledger: _.assign({}, apiResponses.getLedger.full,
-      {parentCloseTime: apiResponses.getLedger.full.closeTime})
-    }],
-    result => {
-      assert.strictEqual(result.result,
-        'E6DB7365949BF9814D76BCC730B01818EB9136A89DB224F3F9F5AAE4569D758E');
-    }
-  );
-
-  createTest(
-    'isConnected',
-    [],
-    result => assert(result.result)
-  );
-
-});