jsgui3-server 0.0.75 → 0.0.79

package/resources/jsbuilder/JS_AST/JS_AST_Node_2.4-Sibling.js

@@ -0,0 +1,93 @@
+
+
+// sibling.next
+// sibling.all
+
+// Sibling relationship
+//  And the index is the index within the parent.
+
+
+
+const JS_AST_Node_All = require('./JS_AST_Node_2.3-All');
+
+const JS_AST_Ordered_Relationship_Node_To_Group = require('./JS_AST_Ordered_Relationship_Node_To_Group');
+
+class JS_AST_Node_Sibling extends JS_AST_Node_All {
+    constructor(spec = {}) {
+        super(spec);
+        const {each_child_node} = this;
+
+
+
+        let index;
+        Object.defineProperty(this, 'index', {
+            get() { 
+
+                if (index === undefined) {
+                    //console.log('this.path', this.path);
+
+                    const s_path = this.path.split('/').filter(s => s.length > 0).map(s => parseInt(s));
+                    //console.log('s_path', s_path);
+
+                    index = s_path[s_path.length - 1];
+
+                    //throw 'NYI';
+                }
+
+                return index;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        
+
+        // sibling.all?
+
+        // .siblings
+        // .siblings.next
+
+        // could say it's an ordinal relationship.
+
+        // Ordered_Relationship_Node_To_Group
+
+        //  with an index property.
+
+        const sibling = new JS_AST_Ordered_Relationship_Node_To_Group({
+            origin: this,
+            name: 'sibling',
+            index: index//,
+            //obtainer: () => this.child_nodes,
+            //iterator: callback => each(this.child_nodes, callback),
+            //each: callback => each(this.child_nodes, callback)//,
+            //select: fn_select => select_child_nodes(fn_select)
+        });
+
+        sibling.previous = new JS_AST_Ordered_Relationship_Node_To_Group({
+            origin: this,
+            name: 'previous-sibling'
+        });
+        sibling.post = new JS_AST_Ordered_Relationship_Node_To_Group({
+            origin: this,
+            name: 'post-sibling'
+        });
+
+        this.sibling = sibling;
+
+        //.previous .next
+        //.pre .post
+
+        // Need to know the position / index within the parent.
+
+
+        // this.sibling.number
+        //  .own_number?
+
+
+
+
+        
+
+    }
+}
+
+module.exports = JS_AST_Node_Sibling;

package/resources/jsbuilder/JS_AST/JS_AST_Node_2.5-Available_In_Scope.js

@@ -0,0 +1,29 @@
+
+const JS_AST_Node_Sibling = require('./JS_AST_Node_2.4-Sibling');
+const JS_AST_Relationship_Node_To_Group = require('./JS_AST_Relationship_Node_To_Group');
+
+class JS_AST_Node_Available_In_Scope extends JS_AST_Node_Sibling {
+    constructor(spec = {}) {
+        super(spec);
+        const {each_child_node} = this;
+        
+
+        // The scope or in_scope relationship object.
+
+        const available_in_scope = new JS_AST_Relationship_Node_To_Group({
+            origin: this,
+            name: 'available_in_scope'//,
+            //obtainer: () => this.child_nodes,
+            //iterator: callback => each(this.child_nodes, callback),
+            //each: callback => each(this.child_nodes, callback)//,
+            //select: fn_select => select_child_nodes(fn_select)
+        });
+
+        this.available_in_scope = available_in_scope;
+
+
+    }
+}
+
+module.exports = JS_AST_Node_Available_In_Scope;
+

package/resources/jsbuilder/JS_AST/JS_AST_Node_2.9-Signature.js

@@ -0,0 +1,116 @@
+
+
+const JS_AST_Node_Available_In_Scope = require('./JS_AST_Node_2.5-Available_In_Scope');
+
+
+class JS_AST_Node_Signature extends JS_AST_Node_Available_In_Scope {
+    constructor(spec = {}) {
+        super(spec);
+        const {each_child_node} = this;
+        let deep_type_signature, type_signature;
+        // and then a more shallow type signature.
+        //   type_signature could go to depth 2 or 3. Let's try it.
+        // Want to be able to get small and usable signatures.
+
+        // Want max depth for the iteration.
+        //  The stop function integrated within the iteration would be useful there to get that done.
+        //  Maybe an 'options' object now params have got more complex.
+
+        const get_deep_type_signature = () => {
+            //let res = '[' + this.type + '(';
+            //if (!deep_type_signature) {
+            //console.log('');
+            //console.log('this.path', this.path);
+            //console.log('this.type', this.type);
+            let res = '' + this.abbreviated_type, inner_res = '', first = true;
+
+            // Only look at child nodes, not full tree here.
+            // each_child_node   inner_deep_iterate
+            //  seems fixed now.
+            // no longer supports max_depth but at least it works now.
+
+            each_child_node(inner_node => {
+                if (!first) inner_res = inner_res + ','
+                inner_res = inner_res + inner_node.deep_type_signature
+                first = false;
+            });
+            //res = res + ')';
+            if (inner_res.length > 0) {
+                res = res + '(' + inner_res + ')';
+            } else {
+
+            }
+            return res;
+        }
+
+        Object.defineProperty(this, 'type_signature', {
+            get() { 
+                if (!type_signature) type_signature = get_deep_type_signature(1);
+                //if (deep_type_signature) return deep_type_signature;
+                return type_signature;
+                
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        Object.defineProperty(this, 'deep_type_signature', {
+            get() { 
+                if (!deep_type_signature) deep_type_signature = get_deep_type_signature(100);
+                //if (deep_type_signature) return deep_type_signature;
+                return deep_type_signature;
+                
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        Object.defineProperty(this, 'signature', {
+            get() { 
+                return this.type_signature
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        this.get_deep_type_signature = get_deep_type_signature;
+
+    }
+}
+
+module.exports = JS_AST_Node_Signature;
+
+
+
+// Scope next...?
+//  A function that iterates backwards through the scope.
+
+// .scoped being a group of those scoped nodes
+
+// node.scope.find.identifier.by.name(n)
+
+// node.scope.all.declaration
+
+// node.scope.each.declaration()
+
+// node.shared.scope.all being all nodes in the shared scope
+// node.scope being the scope internal to that node itself?
+
+// Will have some kinds of more basic processes that deal with scope.
+//  not so OO to begin with, but ability to get the names of all declarations in scope.
+
+// The scope or maybe in_scope relationship could be a useful way to do it.
+//  Also_In_Scope relationship?
+//  Available_In_Scope
+// 2.5-Available_Declarations_In_Scope
+//  Just In_Scope as a relationship works OK.
+//   Available_In_Scope is a bit clearer though. Maybe In_Scope is fine when it's a relationship, it's clear enough maybe.
+
+
+
+
+
+

package/resources/jsbuilder/JS_AST/JS_AST_Node_3-Basics.js

@@ -0,0 +1,160 @@
+//const babel_node_tools = require('../babel/babel_node_tools');
+// Index before query would help.
+
+// Will index the occurrances of various nodes / things.
+
+// Could get more into tree pattern checking too, declaratively saying what to look for and looking for multiple things at once with signature comparisons in a map.
+
+// Indexing at every level looks like it would be useful.
+//  so in order to get the info about how the names relate to nodes we consult indexes.
+
+
+const JS_AST_Node_Signature = require('./JS_AST_Node_2.9-Signature');
+
+// Could make a more specific feature extraction part.
+//  Will come up with more:
+
+// 2.1 Identify
+// 2.2 ??? - Extract_Feature?
+
+// Will identify more information about what JS is contained.
+//  Eg if it's a recognised code library structure that can be extracted.
+//   Identify the main block of declarations in a (library or framework) file.
+//    Identify the variable definitions in there.
+
+// Need more capability here to find and match specified features.
+
+// Asking questions about a piece of code - questions to later determine what it is and how to use it.
+
+// .matches_type_signature(signature)
+
+// . but using a tree is better for checking multiple signatures at once.
+
+
+// May have a .query object.
+//  Somewhat drastic change
+//   and .query will be used through its properties
+
+// .query.child.declaration.child.declarator.name
+// .query.child.declaration.child.declarator.name
+// const q = node.query.child.declaration.child.declarator.name
+
+// exequery(q)
+// q.exe
+
+// q.exe function makes sense for the query.
+
+// can do qres = node.query.child.declaration.child.declarator.name.exe();
+// qures = node.exeq(node.query.child.declaration.child.declarator.name);
+
+// That means cutting down on the amount of potential changes to the non .query querying functionality.
+//  May well be worth keeping them for the moment, until / unless completelty superceded by the query api - apart from perhaps in convenience of the functions themselves.
+//   Then they could be expressed in one line declarations that show the shorthands available for the really nice query operations.
+
+
+
+
+
+
+// Maybe this is 'Explore' rather than 'Query'. Or 'Navigate'.
+//  Providing the relationships will be useful in some cases for the queries and running them.
+
+// The query objects themselves, will be driven by properties.
+//  query obj
+//   property called. creates a query object that is given an array of previous / suffix query words.
+//  Then when the query is built, it gets executed.
+//   Maybe the query execution part will need to be quite substantial.
+//    Probably best to do a stage 1 check / plan of the query, to make sure that it makes sense.
+//     There could be a multitude of inner type functions, such as filtering and finding things - but it will need to either be recursive, or logically progress correctly processing
+//      the query.
+
+// User-friendly query objects are definitely the way forward.
+//  For the moment though, can do more with some simpler (query?) methods such as node.filter.child 
+
+// The .query system will be the best way by far to both create and run some more complex queries in a syntax that closely resembles the English language.
+
+// These are more like core extended???
+//  these are functions / getters / iterators
+
+
+
+
+
+
+
+
+
+
+
+class JS_AST_Node_Basics extends JS_AST_Node_Signature {
+    constructor(spec = {}) {
+        super(spec);
+        //const {deep_iterate, each_child_node, filter_each_child_node} = this;
+
+        const {child_nodes, deep_iterate} = this;
+
+        //const each_child_node = this.each.child;
+        //const filter_each_child_node = this.filter.child;
+
+        // sets the childnodes here.
+        //  will also make available the relevant bable properties.
+
+        // Use the lower level tools to kind of understand the node.
+        //  Provide property getters that will do this.
+
+        // Seeing what pattern / recognised object / pattern it is.
+
+        const filter_deep_iterate = (fn_filter, max_depth, callback) => {
+
+            if (!callback && typeof max_depth === 'function') {
+                callback = max_depth;
+                max_depth = undefined;
+            }
+
+            deep_iterate(max_depth, (js_ast_node, depth, path) => {
+                if (fn_filter(js_ast_node)) callback(js_ast_node, path, depth);
+            })
+        }
+        const inner_deep_iterate = (max_depth, callback) => {
+            if (!callback && typeof max_depth === 'function') {
+                callback = max_depth;
+                max_depth = undefined;
+            }
+            filter_deep_iterate(js_ast_node => js_ast_node !== this, max_depth, callback);
+        }
+        //const filter_inner_deep_iterate = (filter, callback) => inner_deep_iterate((node) => filter(node) ? callback(node) : undefined)
+
+        const filter_by_type_deep_iterate = (type, max_depth, callback) => {
+            if (!callback && typeof max_depth === 'function') {
+                callback = max_depth;
+                max_depth = undefined;
+            }
+            filter_deep_iterate(node => node.type == type, max_depth, callback);
+        }
+
+        const typed_deep_iterate = (babel_type, max_depth, callback) => {
+            if (!callback && typeof max_depth === 'function') {
+                callback = max_depth;
+                max_depth = undefined;
+            }
+            filter_deep_iterate(js_ast_node => js_ast_node.type === babel_type, max_depth, callback);
+        }
+        
+        
+        
+        const filter_inner_nodes_by_type = (type, callback) => {
+            filter_inner_deep_iterate(node => node.type === type, node => callback(node));
+        }
+
+
+        
+        this.inner_deep_iterate = inner_deep_iterate;
+        this.filter_deep_iterate = filter_deep_iterate;
+
+    }
+}
+
+// Indexing may work better with / after these queries.
+//  Then there could be another layer of queries after index.
+
+module.exports = JS_AST_Node_Basics;

package/resources/jsbuilder/JS_AST/JS_AST_Node_3.0.0-Basics_First.js

@@ -0,0 +1,179 @@
+
+
+const JS_AST_Node_Basics = require('./JS_AST_Node_3-Basics');
+
+const JS_AST_Abstract_Node = require('./JS_AST_Abstract_Node');
+const JS_AST_Ordinal = require('./JS_AST_Ordinal');
+//const JS_AST_Relationship = require('./JS_AST_Relationship_Node_To_Group');
+const JS_AST_Ordinal_Relationship = require('./JS_AST_Ordinal_Relationship');
+
+// Could make a more specific feature extraction part.
+//  Will come up with more:
+
+// 2.1 Identify
+// 2.2 ??? - Extract_Feature?
+
+// Will identify more information about what JS is contained.
+//  Eg if it's a recognised code library structure that can be extracted.
+//   Identify the main block of declarations in a (library or framework) file.
+//    Identify the variable definitions in there.
+
+// Need more capability here to find and match specified features.
+
+// Asking questions about a piece of code - questions to later determine what it is and how to use it.
+
+// .matches_type_signature(signature)
+
+// . but using a tree is better for checking multiple signatures at once.
+
+// basically 'deep iterate', though could apply to .child or .ancestor
+
+// First is basically just an ordinal, part of a relationship.
+//  New query system will likely be much better.
+
+
+class JS_AST_Node_Basics_First extends JS_AST_Node_Basics {
+    constructor(spec = {}) {
+        super(spec);
+
+        // An abstract JS AST node
+
+        const index = 0;
+        const {child_nodes} = this;
+
+        
+
+        // first.child.declaration
+        //  meaning it's not 'first.child'.
+
+
+
+        // First is a node condition?
+        //  or short for get first?
+
+        // .first.child
+        //   will need to be first.child.node
+
+        // .first.declaration
+        // .first.child.declaration
+        //   want it to operate as read in English.
+
+        // maybe function chaining is the way?
+
+        // JS_AST_Ordinal
+
+        
+        const ordinal = this.first = new JS_AST_Ordinal({
+            origin: this,
+            //relationship_to: 'first',
+            number: index
+        });
+
+        const {child} = this;
+        
+
+
+
+        // JS_AST_Ordinal_Relationship
+
+
+        // Abstract node with a specified type?
+        //  Or something else?
+        const ordinal_child = ordinal.child = new JS_AST_Ordinal_Relationship({
+            ordinal: ordinal,
+            relationship: child
+        });
+
+        Object.defineProperty(ordinal_child, 'node', {
+            get() { 
+                return child_nodes[index];
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        // then the with things like declaration it would find that item.
+
+
+
+        // first.child should be a property lookup.
+
+        /*
+        Object.defineProperty(first, 'child', {
+            get() { 
+                return root_node;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        */
+
+
+        //const first_child = first.child = new 
+
+        // then the first child is another abstract node.
+
+
+
+
+
+        /*
+
+
+
+        // Could make it a property?
+
+        const get_first_child = () => this.child_nodes[0];
+
+        let cached_first;
+
+        Object.defineProperty(this, 'first', {
+            get() { 
+
+                if (!cached_first) {
+                    cached_first = {
+                        child: get_first_child(),
+                        declaration: get_first_declaration_child(),
+                        identifier: get_first_identifier_child(),
+                        statement: get_first_statement_child(),
+                        expression: get_first_expression_child(),
+                    }
+                }
+
+                return cached_first;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        // it's a JS_AST_Abstract_Node
+        //  meaning we can refer to it without actually having the object.
+
+        // .first is such an abstract node.
+        // .first.child
+        // .first.expression
+        // .first.identifier
+
+        // and .second, .third, .fourth, quite a lot would be of use.
+
+
+
+        
+
+
+
+        // .first.child.node property
+
+
+        // first.child
+
+        // first.child.declaration
+
+        */
+
+
+
+    }
+}
+
+module.exports = JS_AST_Node_Basics_First;

package/resources/jsbuilder/JS_AST/JS_AST_Node_3.0.1-Basics_Second.js

@@ -0,0 +1,88 @@
+
+
+const JS_AST_Node_Basics_First = require('./JS_AST_Node_3.0.0-Basics_First');
+
+const JS_AST_Abstract_Node = require('./JS_AST_Abstract_Node');
+const JS_AST_Ordinal = require('./JS_AST_Ordinal');
+//const JS_AST_Relationship = require('./JS_AST_Relationship_Node_To_Group');
+const JS_AST_Ordinal_Relationship = require('./JS_AST_Ordinal_Relationship');
+
+// Could make a more specific feature extraction part.
+//  Will come up with more:
+
+// 2.1 Identify
+// 2.2 ??? - Extract_Feature?
+
+// Will identify more information about what JS is contained.
+//  Eg if it's a recognised code library structure that can be extracted.
+//   Identify the main block of declarations in a (library or framework) file.
+//    Identify the variable definitions in there.
+
+// Need more capability here to find and match specified features.
+
+// Asking questions about a piece of code - questions to later determine what it is and how to use it.
+
+// .matches_type_signature(signature)
+
+// . but using a tree is better for checking multiple signatures at once.
+
+// basically 'deep iterate', though could apply to .child or .ancestor
+
+class JS_AST_Node_Basics_Second extends JS_AST_Node_Basics_First {
+    constructor(spec = {}) {
+        super(spec);
+
+        // An abstract JS AST node
+
+        const index = 1;
+        const {child_nodes} = this;
+
+        // first.child.declaration
+        //  meaning it's not 'first.child'.
+
+
+
+        // First is a node condition?
+        //  or short for get first?
+
+        // .first.child
+        //   will need to be first.child.node
+
+        // .first.declaration
+        // .first.child.declaration
+        //   want it to operate as read in English.
+
+        // maybe function chaining is the way?
+
+        // JS_AST_Ordinal
+
+        const ordinal = this.second = new JS_AST_Ordinal({
+            origin: this,
+            //relationship_to: 'first',
+            number: index
+        });
+
+        const {child} = this;
+        // JS_AST_Ordinal_Relationship
+        // Abstract node with a specified type?
+        //  Or something else?
+
+        // Relationship of node to node.
+
+        const ordinal_child = ordinal.child = new JS_AST_Ordinal_Relationship({
+            ordinal: ordinal,
+            relationship: child
+        });
+
+        Object.defineProperty(ordinal_child, 'node', {
+            get() { 
+                return child_nodes[index];
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+    }
+}
+
+module.exports = JS_AST_Node_Basics_Second;