jsgui3-server 0.0.75 → 0.0.77

package/resources/jsbuilder/JS_AST/_JS_AST_Node_3.8-Query_Features.js

@@ -0,0 +1,77 @@
+//const babel_node_tools = require('../babel/babel_node_tools');
+
+
+const JS_AST_Node_Basics_Find = require('./JS_AST_Node_3.5-Basics_Find');
+
+// 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.
+
+class JS_AST_Node_Basics_Features extends JS_AST_Node_Basics_Find {
+    constructor(spec = {}) {
+        super(spec);
+        // Getting the assigned values also seems important.
+        // Possibly will be made into some kind of autoquery? Or may be better to do queries lazily, and store the results.
+        
+        // Declared Object features inside a node.
+
+        // If a node 'features' declared objects, then the syntax in which they are declared is not so important.
+        //  This is an abstraction level above that.
+
+        // Want to keep it faitrly generic at this stage
+        //  Will do more with root node interpretation for the moment I expect.
+        //  First priority is to get everything linking together properly in an output file.
+        //  
+        const arr_features_declared_object = [];
+        const features = [];
+        const map_arr_features_by_feature_name = {
+            
+        }
+        Object.defineProperty(this, 'features', {
+            get() { 
+                //if (!features) {
+                //    features = [];
+                //}
+                return features;
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        // get literal names
+        //  or is it value
+
+        // // Assignment Feature?
+
+
+        // Document features make the most sense to work on from the API point of view.
+        //  Or root node features really.
+
+        // Will try loading up and querying an interpreted root node.
+        //  Or jsgui root node interpreted?
+        // Even with that Object.assign trick, we can make it aware, keep that in the general purpose code.
+
+
+        // The imports and exports features are important for linking together the documents.
+
+
+
+
+        
+    }
+}
+
+module.exports = JS_AST_Node_Basics_Features;

package/resources/jsbuilder/JS_AST/query/enable_array_as_queryable.js

@@ -0,0 +1,228 @@
+const {each} = require('lang-mini');
+
+const create_query_execution_fn = (arr, words = []) => {
+    //console.log('words', words);
+
+    /*
+    const {
+        each_child_node, filter_each_child_node,
+        find_node, filter_deep_iterate, filter_inner_deep_iterate, filter_child_nodes_by_type,
+        select_all, select_child, select_inner
+    } = node;
+    */
+
+    let proceed = true;
+
+    
+
+    if (proceed) {
+
+
+
+        //console.log('arr', arr);
+        console.log('* words', words);
+
+        const sentence = words.join(' ');
+        console.log('sentence', sentence);
+
+        // if the first word is collect, apply that query to each of the nodes in the array and amalgamate the results.
+
+        if (words[0] === 'select') {
+            return (selector) => {
+                const res = [];
+                each(arr, node => {
+                    const node_res = node.query_with_words(words).exe(selector);
+                    //console.log('node_res', node_res);
+
+                    if (Array.isArray(node_res)) {
+                        each(node_res, i => {
+                            if (i !== undefined) {
+                                res.push(i);
+                                
+                            } else {
+                                console.trace();
+                                throw 'stop';
+                            }
+                        });
+                    } else {
+                        throw 'stop';
+                    }
+
+                    
+                    
+                })
+                enable_array_as_queryable(res);
+                return res;
+            }
+        } else if (words[0] === 'collect') {
+            return () => {
+                const res = [];
+                each(arr, node => {
+                    const node_res = node.query_with_words(words).exe();
+                    //console.log('node_res', node_res);
+
+                    if (Array.isArray(node_res)) {
+                        each(node_res, i => {
+                            if (i !== undefined) {
+                                res.push(i);
+                                
+                            } else {
+                                console.trace();
+                                throw 'stop';
+                            }
+                        });
+                    } else {
+                        throw 'stop';
+                    }
+
+                    
+                    
+                })
+                enable_array_as_queryable(res);
+                return res;
+            }
+        } else {
+
+            if (words[0] === 'each') {
+                return (callback) => {
+                    //const res = [];
+                    each(arr, node => {
+                        //console.log('words', words);
+                        const node_res = node.query_with_words(words).exe(callback);
+                        //console.log('node_res', node_res);
+
+                        /*
+                        each(node_res, i => {
+                            //res.push(i);
+                            callback(i);
+                        });
+                        */
+                        
+                    })
+                    //return res;
+                }
+            } else if (words[0] === 'find') {
+                return (callback) => {
+                    //const res = [];
+
+                    let res;
+                    each(arr, node => {
+
+                        if (!res) {
+                            //console.log('words', words);
+                            const node_res = node.query_with_words(words).exe(callback);
+                            //console.log('node_res', node_res);
+
+                            //throw 'stop';
+
+                            if (node_res) {
+                                res = node_res;
+                            } else {
+                                throw 'stop';
+                            }
+                        }
+                        
+
+                        
+
+                        /*
+                        each(node_res, i => {
+                            //res.push(i);
+                            callback(i);
+                        });
+                        */
+                        
+                    })
+                    return res;
+                }
+            } else {
+                throw 'NYI';
+            }
+
+            
+            
+        }
+
+
+    }
+
+    
+
+
+    throw 'NYI';
+    
+}
+
+
+
+const create_query = (arr, words = []) => {
+
+
+
+    const res = {
+        //message1: "hello",
+        //message2: "everyone"
+    };
+    
+    const handler2 = {
+        get: function(target, prop, receiver) {
+
+            //console.log('target', target);
+            //console.log('prop', prop);
+            //console.log('receiver', receiver);
+
+            //console.log('target === res', target === res);
+
+            if (target === res) {
+
+                if (prop === 'exe') {
+
+                    //throw 'stop';
+
+                    return create_query_execution_fn(arr, words);
+
+                    //throw 'NYI'
+
+                    // return the execution function.
+
+
+
+                } else if (prop === 'qstring') {
+                    return words.join('.');
+                } else {
+                    words.push(prop);
+                    return create_query(arr, words);
+                }
+
+            } else {
+                throw 'stop';
+            }
+        }
+    };
+    
+    const proxy2 = new Proxy(res, handler2);
+
+    return proxy2;
+}
+
+const enable_array_as_queryable = (arr) => {
+
+    let proceed = true;
+    //console.log('arr', arr);
+
+    each(arr, item => {
+        //console.log('item', item);
+        //if (!Array.isArray(item)) proceed = false;
+        if (!item || !item.babel) {
+            proceed = false;
+        }
+    })
+
+    // will of course provide a query property.
+
+    if (!arr.query && proceed) arr.query = create_query(arr);
+    return arr;
+
+}
+
+module.exports = enable_array_as_queryable;