QRequire, compiling, dependencies

.gitignore

+.idea/*
+.idea/
+node_modules/*

.idea/modules.xml

-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/qscript.iml" filepath="$PROJECT_DIR$/.idea/qscript.iml" />
-    </modules>
-  </component>
-</project>
\ No newline at end of file

.idea/qscript.iml

-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/temp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>
\ No newline at end of file

bin/QRequire.js

+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * *
+ */
+;// QUOKKA 2017
+// By zibx on 6/2/17.
+
+module.exports = (function () {
+    'use strict';
+    var slice = [].slice;
+    var waiting = {};
+    var deps = {};
+    var Waiter = function(args, fn){
+        var argsPos = this.argsPos = {}, i, _i;
+        this.args = args;
+        this.deps = args.slice();
+        this.count = args.length;
+        this.fn = fn;
+
+        for( i = 0, _i = args.length; i < _i; i++){
+            argsPos[args[i]] = i;
+        }
+    };
+    Waiter.prototype = {
+        sub: function(){
+            this.count--;
+            this.may();
+        },
+        may: function(){
+            var _self = this;
+            if(!this.count) {
+                var res = this.res = this.fn.apply(this, this.args);
+                if(res) {
+                    if (res instanceof Array) {
+                        res.forEach(function(res){
+                            if(!res)
+                                debugger;
+                            deps[res.namespace + '.' + res.type] = _self;
+                        });
+
+                    }
+
+                    if (res.namespace && res.type) {
+                        deps[res.namespace + '.' + res.type] = this;
+                    }
+                }
+                delete this.args;
+                delete this.argsPos;
+            }
+        },
+        set: function(name, val){
+            this.args[this.argsPos[name]] = val;
+            this.sub();
+        }
+    };
+    var QRequire = function(){
+        var args = slice.call(arguments),
+            fn = args.pop(),
+
+            waiter = new Waiter(args, fn),
+            i, _i, arg;
+
+        for( i = 0, _i = args.length; i < _i; i++){
+            arg = args[i];
+            if(!(arg in waiting)){
+                waiting[arg] = [];
+            }
+            if(!Array.isArray(waiting[arg]))
+                waiter.set(arg, waiting[arg]);
+            else {
+                waiting[arg].push(waiter);
+                if(arg.indexOf('.')===-1){
+                    QRequire.loaded(arg, require(arg));
+                }
+            }
+        }
+
+        //waiter.may();
+    };
+    QRequire.loaded = function(name, obj){
+        console.log(name, typeof obj)
+        var waiter = waiting[name];
+        if(waiter instanceof Array){
+            for( var i = 0, _i = waiter.length; i < _i; i++ ){
+                waiter[i].set(name, obj);
+            }
+        }
+        waiting[name] = obj;
+    };
+
+    QRequire.deps = function(name){
+        return (deps[name] || {}).deps;
+    };
+    return QRequire;
+})();
\ No newline at end of file

bin/TypeTable.js

+module.exports =
+    QRequire('z-observable', function(
+        observable
+    ) {
+        function Node(name) {
+            this.children = {};
+            this.name = name || "";
+            this.namespace = name || "";
+            this.ctor = null;
+        }
+
+        Node.prototype = {
+            findOne: function (path) {
+                if (path.length <= 0)
+                    return this;
+
+                var targetChild = this.children[path[0]];
+                if (!targetChild)
+                    return void(0);
+                return targetChild.findOne(path.splice(1));
+            },
+            findAll: function (name) {
+                var ret = [];
+
+                for (var key in this.children)
+                    if (this.children.hasOwnProperty(key)) {
+                        if (this.children[key].name == name)
+                            ret.push(this.children[key]);
+                        ret = ret.concat(this.children[key].findAll(name))
+                    }
+
+                return ret;
+            }
+        };
+        var table = new Node();
+
+        var TypeTable = {
+            on: observable.prototype.on,
+            fire: observable.prototype.fire,
+            eventList: {},
+            registerType: function (namespace, name, ctor) {
+                var path = namespace.split('.');
+
+                if (!ctor) {
+                    ctor = name;
+                    name = path.splice(-1)[0];
+                }
+
+                ctor.namespace = namespace;
+                ctor.type = name;
+
+                var currentNode = table;
+                for (var i = 0; i < path.length; i++) {
+
+                    if (!currentNode.children[path[i]]) {
+                        currentNode.children[path[i]] = new Node(path[i]);
+                    }
+
+                    currentNode = currentNode.children[path[i]];
+                }
+
+                var typeNode = new Node(name);
+                typeNode.ctor = ctor;
+                typeNode.namespace = path.join('.');
+                currentNode.children[name] = typeNode;
+
+                (function () {
+
+                    var pointer = this.Q = this.Q || {};
+                    var targetNode =
+                        path.reduce(function (pointer, name) {
+                            pointer = pointer[name] = pointer[name] || {};
+                            return pointer;
+                        }, pointer);
+                    targetNode[name] = ctor;
+                }).call(null);
+                this.fire('loaded', namespace, name, ctor);
+
+                QRequire.loaded(ctor.namespace+'.'+ctor.type, ctor);
+
+            },
+            search: function (namespace, name) {
+                namespace = namespace.split('.');
+                if (!name)
+                    name = namespace.splice(-1)[0];
+
+                var ns = namespace.length > 0 ? table.findOne(namespace) : table;
+                var results = ns.findAll(name);
+
+                return results;
+            },
+            getType: function (namespace, name) {
+                namespace = namespace.split('.');
+                if (!name)
+                    name = namespace.splice(-1)[0];
+                var ns = namespace.length > 0 ? table.findOne(namespace) : table;
+
+                if (!ns) {
+                    throw new Error("Can't find " + name + " in " + namespace + '\n\r' + console.log(table));
+                }
+
+                var results = ns.findAll(name);
+
+                //TODO add exception handling
+                if (results.length > 0)
+
+                    return results[0].ctor;
+            }
+        };
+
+        TypeTable.registerType('Core', 'TypeTable', TypeTable);
+
+        return TypeTable;
+    });

bin/cmd.js

@@ -3,4 +3,65 @@
  * Created by zibx on 5/30/17.
  */
 var args = process.argv.slice(2);
-console.log('arguments cmd', args);
+var fileName = args[0];
\ No newline at end of file
+var QRequire = global.QRequire = require('./QRequire'),
+    TypeTable = require('./TypeTable');
+
+QRequire('quokka-script', 'quokka-core', 'Core.TypeTable', 'fs', function(qs, QCore, TypeTable, fs) {
+
+    var cache = {};
+    var getName = function (name, all) {
+        var ns = all[name].namespace;
+        if (ns)
+            return ns + '.' + name;
+        else
+            return name;
+    };
+    var startDepsResolve = function (main, all, store) {
+        store = store || {names: {}, list: []};
+
+        var deps = all[main].require, depName, fullName;
+        for (depName in deps) {
+            if(!(depName in store.names)) {
+                startDepsResolve(depName, all, store);
+            }
+        }
+
+        fullName = getName(main, all);
+        //var cfg = TypeTable.search(fullName);
+        /*if (cfg.length) {
+            cfg = cfg[0];
+            console.log(fullName, cfg.ctor.path)
+        } else
+             ;//throw new Error('No source for '+fullName)
+        */
+        var dep = QRequire.deps(fullName);
+        if(!(fullName in store.names)) {
+            store.names[fullName] = dep;
+            store.list.push({name: fullName, deps: dep});
+        }
+
+        /*cache[fullName] = {
+            require: deps ? Object.keys(deps).map(function (name) {
+                    return getName(name, all);
+                }) : [], code: 'code', cfg: cfg
+        };*/
+        return store;
+    };
+
+    qs({
+        lib: [QCore.dir],
+        typeTable: TypeTable,
+        source: fs.readFileSync(fileName) + '',
+        newWay: true
+    }, function (result) {
+        var mainObj = result.main;
+        var deps = startDepsResolve(mainObj, result.world);
+        cache
+
+    });
+    console.log('arguments cmd', args);
+    console.log('Building:', fileName);
+    var open = require('open');
+});
+//open('http://ya.ru')
\ No newline at end of file

package.json

@@ -6,6 +6,12 @@
   "bin": {
     "qscript": "bin/cmd.js"
   },
+  "dependencies": {
+    "quokka-script": "*",
+    "open": "*",
+    "quokka-core": "*",
+    "z-observable": "*"
+  },
   "scripts": {
     "test": "npm run test"
   },

test/test1.qs

-#!/usr/bin/env qscript
-def App myApp
-  port: 8005
+//#!/usr/bin/env qscript
+//def Server myApp
+//  port: 8050
 
 
 def Page main
-  Slider s1: 10
+  Slider s1: 10
\ No newline at end of file
+  div: ee
+  td: de
\ No newline at end of file