jsgui3-server 0.0.121 → 0.0.123

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

@@ -1,160 +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.
-
+//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

@@ -1,179 +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
-
-        */
-
-
-
-    }
-}
-
+
+
+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;