Merge pull request #232 from sumanjs/dev

Dev

.travis.yml

@@ -16,11 +16,11 @@ addons:
     packages:
       - g++-4.8
 
-before_install: 'if [[ `npm -v` != 4* ]]; then npm i -g npm@4; fi'
+before_install: './dev-scripts/travis/before_install.sh'
 install:
-  - 'npm install --silent --no-optional > /dev/null 2>&1'
-script: 'rm -rf node_modules && npm cache clean && npm install istanbul --silent > /dev/null 2>&1 && npm link -f --silent > /dev/null 2>&1 && npm link suman -f --silent  > /dev/null 2>&1 && suman --force test/src/dev/node/injection.test.js'
-after_script: 'npm install -g coveralls && cat coverage/lcov.info | coveralls'
+  - './dev-scripts/travis/install.sh'
+script: './dev-scripts/travis/script.sh'
+after_script: './dev-scripts/travis/after_script.sh'
 notifications:
   email: false
   slack:

CONTRIBUTING.md

@@ -35,3 +35,13 @@ Once you submit the PR to master, CI/CD tests will run, then if they pass, we de
 You can use this tool to clone all the SumanJS projects onto your machine:
 
 This project will run the ./build.sh file and ./contribute.sh file in each project.
+
+
+
+# Release steps
+
+1. update bash completion in case command line arguments have changed
+
+`$ suman --completion > scripts/suman-completion.sh`
+
+2. ?

dev-scripts/exp/exp.js

@@ -1,118 +1,57 @@
 #!/usr/bin/env node
 
-const v = {
-  z: true,
-  foo: {two: 2}
-};
-
-let x = Object.setPrototypeOf({}, v);
-
-x.foo = 3;
-
-console.log(x);
-console.log(v);
-
-function* foo() {
-  yield 1;
-  yield 2;
-  yield 3;
-}
-
-for (let o of foo()) {
-  console.log(o);
-}
-
-console.log(Object.keys(new Map({a: 'b'})));
-
- x = {};
-
-x.retries(5)
-.foo()
-.run(t => {
+// (async function(){
+//
+//   let z= await 5;
+//   console.log('z => ',z);
+//
+// })();
 
-});
 
-describe('danger')
-.run(function () {});
 
-const Promise = require('bluebird');
-const async = require('async');
+// Object.keys({a:'b','c':'cr'}).forEach(function(k){
+//   console.log('k => ', k);
+//   throw 'boo';
+// });
 
-async.series({
-
-    a: async function (cb) {
-      return Promise.delay(500).then(v => 'zzz');
-    },
-
-    b: async function (cb) {
-      // process.nextTick(cb, null, 'bbb');
-      let c = await Promise.delay(500).then(v => 'hopkins');
-      return c;
-      // cb(null, 'xxx');
-    }
+//
+// const assert = require('assert');
+// assert.equal(typeof (()=>{}).prototype, 'undefined');
 
-  },
-  function (err, results) {
+// that's cool that arrow functions don't have a prototype property
+// why not create a special kind of function that has no prototype?
+// we only use the prototype, 5% of the time, or less
 
-    if (err) throw err;
-    console.log('results => ', results);
-    process.exit(0);
-  });
+// the existing way
 
-// inject(j => {
-//
-//   return j.inject({
-//     a: function(cb){
-//
-//     },
-//
-//     b: function (cb) {
-//
-//     }
-//   });
+// let fn1 = function(){
 //
-//   return [j.inject('av', function (cb) {
-//
-//
-//   })];
+// };
 //
-//   // b.$injected.x = z;
+// assert.equal(typeof fn1.prototype, 'object');
 //
-// });
-
-// console.log(typeof [][Symbol.iterator]);
-
-// const x = {
-//   watch: {
+// // why not a prototype-less function
+// let fn2 = function(){
 //
+// };
 //
-//     per: {
 //
-//       foo: {
-//         exec: 'suman test/*.js',
-//         include: [],
-//         exclude: [],
-//         confOverride: {},
-//         env: {}
-//       },
+// const time = Date.now();
 //
-//       bar: {
-//         exec: 'suman --browser test/front-end/*.js',
-//         include: [],
-//         exclude: [],
-//         confOverride: {}
-//       },
 //
-//       baz: {
-//         exec: 'exec "${SUMAN_CHANGED_TEST_FILE}"',
-//         include: [],
-//         exclude: [],
-//         confOverride: {
+// for(let i = 0; i < 1000000; i++){
+//   var z = function () {
 //
-//         }
-//       }
+//   }
+// }
 //
-//     }
 //
-//   }
-// };
+// console.log(Date.now() - time);
+
+
+let err = false;
+
+let z  = !err;
+
+
+console.log('z => ',z );

dev-scripts/exp/exp.sh

@@ -6,4 +6,14 @@
 #echo "global_modules => $global_modules"
 
 
-sh $(dirname $0)/exp.js
+#sh $(dirname $0)/exp.js
+
+json_array=\''["one","two","three"]'\';
+
+function getJSON {
+   node -pe "JSON.parse($json_array).join('\n')"
+}
+
+getJSON | while read line; do
+    echo "$line"
+done

dev-scripts/exp/exp3.d.ts

@@ -1,2 +1,9 @@
-declare type T = (x: number) => boolean;
-declare let fn: (a: string, b: boolean, c: T) => void;
+declare class Person {
+    name: string;
+    constructor(name: string);
+    greet(greeting: string): string;
+}
+interface Person {
+    hi: typeof Person.prototype.greet;
+}
+declare const p: Person;

dev-scripts/exp/exp3.js

@@ -1,6 +1,11 @@
-var fn = function (a, b, c) { c(); };
-fn('yes', true, (function () {
-}));
-fn('yes', true, (function () {
-}));
-debugger;
+var Person = (function () {
+    function Person(name) {
+        this.name = name;
+    }
+    Person.prototype.greet = function (greeting) { return greeting + ", " + this.name; };
+    return Person;
+}());
+Person.prototype.hi = Person.prototype.greet;
+var p = new Person("Alice");
+console.log(p.greet("Hey"));
+console.log(p.hi("Hi"));

dev-scripts/exp/exp3.ts

@@ -1,15 +1,33 @@
 
+//
+// type T = (x: number) => boolean;
+//
+// let fn = function(a: string, b: boolean, c: T){ c()};
+//
+// fn('yes', true, (() => {
+//
+// }) as any);
+//
+// fn('yes', true, <any>(() => {
+//
+// }));
+//
+// debugger;
+
+
+class Person {
+  constructor(public name: string) {}
+  greet(greeting: string): string { return `${greeting}, ${this.name}`; }
+}
+
+interface Person {
+  hi: typeof Person.prototype.greet;
+}
+
+
+Person.prototype.hi = Person.prototype.greet;
+
+const p = new Person("Alice");
+console.log(p.greet("Hey"));
+console.log(p.hi("Hi"));
 
-type T = (x: number) => boolean;
-
-let fn = function(a: string, b: boolean, c: T){ c()};
-
-fn('yes', true, (() => {
-
-}) as any);
-
-fn('yes', true, <any>(() => {
-
-}));
-
-debugger;

dev-scripts/exp/exp4.d.ts

@@ -0,0 +1,4 @@
+declare const suman: any;
+declare const Test: any;
+declare const async: any;
+declare let count: number;

dev-scripts/exp/exp4.js

@@ -1,27 +1,64 @@
 #!/usr/bin/env node
 'use strict';
-
-const suman = require('suman');
-const {Test} = suman.init(module, {
-  forceParallel: true  // parallel, not parallel-max
-});
-
-///////////////////////////////////////////////////////////////////////
-
-let count = 0;
-
-Test.create(function (b, test) {
-
-  test('tomorrow', t => {
-
-    t.done();
-    debugger;
-    // const x = t.skirt.foo;
-    // console.log(x);
-    t.assert(true);
-    t.assert.equal(true, true);
-    t.expect(function () {}).to.not.throw();
-
-  });
-
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [0, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var suman = require('suman');
+var Test = suman.init(module, {
+    forceParallel: true
+}).Test;
+var async = require('async');
+var count = 0;
+async.series({
+    a: function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, 300];
+                    case 1:
+                        _a.sent();
+                        return [2, 5];
+                }
+            });
+        });
+    }
+}, function (err, results) {
+    if (err) {
+        throw err;
+    }
+    console.log('results => ', results);
+    Test.create(function (b, test) {
+    });
 });