refactoring and as-atelier-export

Author: doublefint

commands/compile.js

@@ -0,0 +1,251 @@
+const { workspace, window } = require('vscode')
+
+let api = {
+    putDoc: () => {}, 
+    compile: (  ) => {} 
+}
+
+let log = msg => console.log( 'cos.compile:', msg )
+
+// read from package.json, see below
+let languages = [ 'cacheobjectscript', 'cacheobjectscriptinclude' ];
+
+const consoleOutput = ( output, defaultOutput = '' ) => {
+
+    const isArr = output instanceof Array
+    let out = isArr ? output.join( '\n' ) 
+                    : ( output || defaultOutput ) + ''
+    ;
+
+    out = out.replace( /^[\s\r\n]+/, '' )
+
+    if ( out ) {
+        log( out )
+    }
+
+}
+
+
+const checkEditor = () => {
+
+    if ( !window.activeTextEditor ){
+        log( 'No active editor, open one at first' )
+        return false 
+    }
+
+    const openedDoc = window.activeTextEditor.document
+    if ( !openedDoc ){
+        log( 'Open a Caché ObjectScript file first.' )
+        return false
+    }
+
+    const fullname = openedDoc.fileName
+    if ( !fullname ){
+        log( 'You must save the document first' )
+        return false
+    }
+
+    const language = openedDoc.languageId
+    const supported = ~languages.indexOf( language )
+    if ( !supported ){
+        log( 
+`Document ${ fullname } cannot be compiled in Caché 
+( type ${ language } unsupported )` 
+        )
+        return false
+    }
+
+    return true
+
+}
+
+
+// is name correlate with code ?
+// if ( atelier ) {
+//  testClass({ codename: 'test.class.cls', filename: 'class.cls' })
+// } else {
+//  testClass({ codename: 'test.class.cls', filename: 'test.class.cls' })
+//}
+const testClass = ( { codename, filename }) => {
+
+    const parts = codename.split( /\./g )
+                          .filter( s => !!s ) // for codename '.cls'
+
+    if ( parts.length < 3 ) { // 'cls' or empty 
+        log( 
+`Unable to detect class name in source code of ${ filename }.\n
+Is it a valid Caché ObjectScript class?`
+        )
+        return false
+    }
+
+    // NOTE: by default used package 'User'
+    // else if ( parts.length === 2 ){
+        // parts.unshift( 'User' ) //package by default
+        // or need detect 'import' directive
+    //}
+
+    const codenameL = codename.toLowerCase()
+    const filenameL = filename.toLowerCase()
+    const isContain = ~codenameL.indexOf( filenameL )
+
+    if ( !isContain ){ 
+
+        log(
+`You tried to compile class named '${ docname }' in file '${ filename }'.\n
+Did you forget to rename the file/class to correspond to each other?`
+        )
+        return false
+
+    }
+    return true
+
+}
+
+
+const testRoutine = ({ codename, filename, type }) => {
+
+    if ( !codename ){
+
+        log(
+
+`Unable to detect routine name in source code of ${ filename }.
+Is it a valid Caché ObjectScript routine? Did you forget to define a routine
+name in the file on the first line? Routine code example:
+
+ROUTINE RtnName [Type=MAC]
+  write "routine code here"
+  Quit
+`
+        )
+        return false
+
+    }
+
+    const isContain = ~codename.toLowerCase().indexOf( filename.toLowerCase() ) 
+    if ( !isContain ) {
+        log(
+            `You tried to compile routine named "${ cacheDocName }" (.${ rtnType }) in file "${ 
+                matchingFileName }".\nDid you forget to rename the file/routine to correspond to each other? `
+            + `Routine code example: \n\n`
+            + `ROUTINE ${ matchingName } [Type=${ rtnType }]`
+            + `\n    write "routine code here"\n    quit`
+        )
+        return false
+    }
+
+    return true
+
+
+}
+
+const AnyErrors = codename => ( err, res, keyword ) => {
+
+    if ( err ){
+        const errtext = err.code ? err.code + ' ' + err.message : err
+        log( `Unable to ${ keyword } ${ codename }: ${ errtext }` )
+        return true
+    }
+
+
+    if ( !res || !res.status || !( res.status.errors instanceof Array ) ){
+        log( `Unknown response from Atelier API while trying to ${ 
+            keyword } ${ codename }: ${ res }` )
+        return true
+    }
+
+    if ( res.result && res.result.status ){
+       log( res.result.status )
+       return true
+    }
+
+    if ( res.status.errors.length !== 0 ){
+        log( 
+`Unable to ${ keyword } ${ codename }: ${ res.status.errors.summary }
+${res.console }\n\n${ res.status.errors.join('\n') }` 
+        )
+        return true 
+    }
+
+    return false;
+
+}
+
+
+
+/**
+* Import and compile current file.
+*/
+const cosCompile = () => {
+
+    if ( !checkEditor() ) return 
+
+    const activedoc = window.activeTextEditor.document
+    const fullname = activedoc.fileName
+    log( `Saving ${ fullname }...` )
+
+    //drop folders, all after last '/'
+    let filename = ( fullname.match( /[^\\\/]+$/ ) || [] )[ 0 ] || ''
+
+    let code = activedoc.getText()
+                      .replace( /\/\/[^\r\n]*\r?\n/g, '' ) //normalize eol?
+
+    let codename; //server side name
+
+    const isClass = /\.cls$/i.test( fullname )
+    if ( isClass ) {
+
+        // Caché class files can be placed hierarchically (e.g. /src/Package/Class.cls),
+        // so we pick the class name from the class definition itself
+        const clsrgx = code.match( /Class ([^\s]+)/i ) // rgx = ['Class test.class', 'test.class']
+        codename = ( clsrgx || [] )[ 1 ] || '' 
+        codename += '.cls' // test.class.cls
+
+        // is name correlate with code ?
+        // if ( atelier_way ) {
+        //  testClass({ codename: 'test.class.cls', filename: 'class.cls' })
+        // } else {
+        //  testClass({ codename: 'test.class.cls', filename: 'test.class.cls' })
+        //}
+        if ( !testClass( { codename, filename } ) ) return
+
+    } else { // routine cases
+
+        // routine: routine name must be declared in a routine
+        const rtnrgx = code.match( /routine ([^\s]+)/i ) 
+        codename = ( rtnrgx || [] )[ 1 ] || ''
+        const type = ( code.match( /routine\s+[^\s]+\s+\[.*type=([a-z]{3,})/i ) || [] )[ 1 ] || 'MAC'
+        codename += '.' + type 
+        if ( !testRoutine( { codename, filename, type } ) ) return
+
+    }
+
+    const content = code.split( /\r?\n/g ) // code lines
+    const anyErrors = AnyErrors( codename )
+
+    const onCompile = ( err, res ) => {
+        if ( anyErrors( err, res, 'compile' ) ) return
+        consoleOutput( res.console || "Done." )
+    }
+
+    const onSave = ( err, res ) => {
+        if ( anyErrors( err, res, 'save' ) ) return
+        consoleOutput( res.console )
+        api.compile( codename, onCompile )
+    }
+
+    api.putDoc( 
+        codename, 
+        { enc: false, content }, 
+        { ignoreConflict: true }, 
+        onSave 
+    )
+
+}
+
+module.exports = env => {
+
+    ({ log, api, languages } = env );
+    return cosCompile
+
+}

commands/export/doc-to-file-as-atelier.js

@@ -0,0 +1,12 @@
+//for example: 'mypkg.subpkg.myclass.cls'
+// return 'mypkg/subpkg/'
+module.exports = docname => {
+
+    const parts = docname.split( '.' ) // [ 'mypkg', 'subpkg', 'myclass', 'cls' ]
+    const packagesEnd = parts.length - 2 // name and extension
+    return [
+        parts.slice( 0, packagesEnd ).join( '/' ), // packages to subfolders
+        parts.slice( packagesEnd ).join( '.' )
+    ].join('/') 
+
+}

commands/export/index.js

@@ -0,0 +1,113 @@
+const fs = require('fs')
+const path = require('path')
+
+//export 'mypkg.subpkg.name.cls' as /mypkg/subpkg/name.cls
+const atelier_filename = require('./doc-to-file-as-atelier')
+const mkdir = require('./mkdir-p-sync') // mkdir -p 'path/to/file'
+
+// see module.exports
+let api = {
+    getDocNames: ( opts, cb ) => cb( null, {} ),
+    getDoc: ( docname, cb ) => cb( null, {} ) 
+}
+let log = (...msg) => console.log('cos.export:', ...msg ) 
+// export options
+let root = '.'
+let folder = 'src'
+let category = '*'
+let generated = 0
+let filter  = ''
+let atelier = false
+let doc2file = docname => docname
+
+
+// Export one document 
+const docExport = ( doc, cb ) => {
+
+    if ( !root ){
+        log('')
+        log('Open folder before export - Ctrl+K, Ctrl+O')
+        return cb()
+    }
+
+    // atelier: 'mypkg.subpkg.myclass.cls' => 'mypkg/subpkg/myclass.cls'
+    const filename = doc2file( doc.name )
+    const fullname = [ root, folder, doc.cat, filename ].join('/')
+    const folders = path.dirname( fullname )
+
+    if ( !fs.existsSync( folders ) ) mkdir( folders )
+    fs.writeFileSync( fullname, doc.content.join( '\n' ) )
+
+    log( `${ doc.name } -> ${ fullname }` )
+    cb( null, {} )
+
+}
+
+const Loaded = cb => ( err, json ) => { 
+
+    if ( err ) {
+        log('')
+        // doc.name ?
+        log( `ERROR!!!:  ${ JSON.stringify( err )}` ) 
+        log('')
+        return cb( err )
+    }
+
+    docExport( json.result, cb )
+
+}
+
+const load = ( doc, cb )  => api.getDoc( encodeURI( doc.name ), Loaded( cb ) )
+
+const docsExport = ( docs, cb ) => {
+
+    let doc, loadcb; 
+    while ( doc = docs.shift() ){
+
+        loadcb = ( err, data )=> { 
+            if ( err ) log( `ERROR: ${ JSON.stringify( doc ) } ${ JSON.stringify( err ) }` )
+        }
+
+        load( doc, loadcb )
+
+    }
+
+}
+
+const onGetDocs = ( err, json ) => {
+    
+    if ( err ) return log( 'getDocs ERROR' )
+
+    const list = json.result.content
+    log( '' )
+    log( 'list: ' + list.length )
+    const docFilter = doc => {
+        return ( doc.cat !== 'CSP' ) &&
+                 ( doc.name.substring( 0, 1 ) !== '%' ) &&
+                 ( doc.name.substring( 0, 12 ) !== 'INFORMATION.' )
+    }
+    const docs = list.filter( docFilter )
+    log( 'without % and CSP and INFORMATION: ' + docs.length )
+    log( '' )
+
+    docsExport( docs, () => {
+        log( '' )
+        log( 'Export completed.' )
+    })
+
+}
+
+/**
+ * Export all classes/routines in a namespace to working directory.
+*/
+module.exports = environment => {
+
+    ( { api, log, options } = environment );
+    ( { root, folder, atelier, category, generated, filter } = options );
+    if ( atelier ) doc2file = docname => atelier_filename( docname )
+
+    return () => {
+        api.getDocNames( { category, generated, filter }, onGetDocs )
+    }
+
+}