javonet-ruby-sdk 2.5.7 → 2.5.9

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/generator/handler/shared/body/SharedInvokeStaticMethodBodyHandler.js

@@ -0,0 +1,39 @@
+const OS = require('os')
+const AbstractGeneratorHandler = require('../../AbstractGeneratorHandler')
+const CommonGenerator = require('../../../internal/CommonGenerator')
+const SharedHandlerType = require('../../../internal/SharedHandlerType')
+const StringUtils = require('../../../utils/StringUtils')
+const { RuntimeName } = require('../../../../../..')
+
+class SharedInvokeStaticMethodBodyHandler extends AbstractGeneratorHandler {
+    generate_code(existing_string_builder, common_command, used_object, handlers) {
+        handlers.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE].generate_code(
+            existing_string_builder,
+            common_command,
+            used_object.payload[1],
+            handlers
+        )
+        existing_string_builder.append('Javonet.inMemory().')
+        existing_string_builder.append(
+            StringUtils.capitalizeFirstLetter(Object.keys(RuntimeName)[common_command.runtimeName])
+        )
+        existing_string_builder.append('().')
+        existing_string_builder.append('getType("')
+        existing_string_builder.append(used_object.payload[3])
+        existing_string_builder.append('").')
+        existing_string_builder.append('invokeStaticMethod("')
+        existing_string_builder.append(used_object.payload[0])
+        existing_string_builder.append('", ')
+        CommonGenerator.process_method_arguments_names(
+            existing_string_builder,
+            common_command,
+            used_object.payload[5],
+            handlers
+        )
+        existing_string_builder.append(').')
+        existing_string_builder.append('execute().resultValue')
+        existing_string_builder.append(OS.EOL)
+    }
+}
+
+module.exports = SharedInvokeStaticMethodBodyHandler

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/generator/internal/CommonGenerator.js

@@ -0,0 +1,39 @@
+const SharedHandlerType = require('./SharedHandlerType')
+
+class CommonGenerator {
+    static process_method_arguments(
+        existing_string_builder,
+        common_command,
+        type_array,
+        name_array,
+        handlers
+    ) {
+        for (let i = 0; i < name_array.length; i++) {
+            handlers.SHARED_HANDLER[SharedHandlerType.ARGUMENT_NAME].generate_code(
+                existing_string_builder,
+                common_command,
+                name_array[i],
+                handlers
+            )
+            if (i < name_array.length - 1) {
+                existing_string_builder.append(', ')
+            }
+        }
+    }
+
+    static process_method_arguments_names(existing_string_builder, common_command, name_array, handlers) {
+        for (let i = 0; i < name_array.length; i++) {
+            handlers.SHARED_HANDLER[SharedHandlerType.ARGUMENT_NAME].generate_code(
+                existing_string_builder,
+                common_command,
+                name_array[i],
+                handlers
+            )
+            if (i < name_array.length - 1) {
+                existing_string_builder.append(', ')
+            }
+        }
+    }
+}
+
+module.exports = CommonGenerator

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/generator/internal/NodejsStringBuilder.js

@@ -0,0 +1,17 @@
+class NodejsStringBuilder {
+    constructor() {
+        this.string = ''
+    }
+
+    string
+
+    append(string) {
+        this.string += string
+    }
+
+    getString() {
+        return this.string
+    }
+}
+
+module.exports = NodejsStringBuilder

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/generator/internal/SharedHandlerType.js

@@ -6,5 +6,5 @@ module.exports = {
     MODIFIER: 4,
     TYPE: 5,
     CLAZZ_INSTANCE: 6,
-    RETURN_TYPE: 7
-}
+    RETURN_TYPE: 7,
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/generator/utils/StringUtils.js

@@ -1,7 +1,7 @@
 class StringUtils {
     static capitalizeFirstLetter(string) {
-        return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+        return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase()
     }
 }
 
-module.exports = StringUtils
+module.exports = StringUtils

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/AbstractHandler.js

@@ -1,12 +1,13 @@
-const Handler = require('./Handler')
-const Command = require('../../utils/Command')
+const { Command } = require('../../..')
 
 class AbstractHandler {
+    handlers = []
+
     constructor() {
-        if(new.target === AbstractHandler)
-            throw new TypeError('You cannot instantiate abstract class')
+        if (new.target === AbstractHandler) throw new TypeError('You cannot instantiate abstract class')
     }
 
+    // eslint-disable-next-line no-unused-vars
     process(command) {
         throw new Error('process must be implemented')
     }
@@ -17,23 +18,22 @@ class AbstractHandler {
     }
 
     iterate(cmd) {
-        for(let i = 0; i < cmd.payload.length; i++) {
-            
-            if(cmd.payload[i] instanceof Command) {
+        for (let i = 0; i < cmd.payload.length; i++) {
+            if (cmd.payload[i] instanceof Command) {
                 let inner = cmd.payload[i]
-                cmd.payload[i] = Handler.handlers[inner.commandType].handleCommand(inner)
+                cmd.payload[i] = this.handlers[inner.commandType].handleCommand(inner)
             }
         }
     }
 
     process_stack_trace(error, class_name) {
-        let stackTraceArray = error.stack.split('\n').map(frame => frame.trim());
+        let stackTraceArray = error.stack.split('\n').map((frame) => frame.trim())
         stackTraceArray.forEach((str, index) => {
             if (str.includes(class_name)) {
-                stackTraceArray = stackTraceArray.slice(0, index).filter((s) => !s.includes(class_name));
+                stackTraceArray = stackTraceArray.slice(0, index).filter((s) => !s.includes(class_name))
             }
-        });
-        error.stack = stackTraceArray.join(" \n ")
+        })
+        error.stack = stackTraceArray.join(' \n ')
         return error
     }
 }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/ArrayGetItemHandler.js

@@ -1,5 +1,4 @@
-const AbstractHandler = require("./AbstractHandler")
-
+const AbstractHandler = require('./AbstractHandler')
 
 class ArrayGetItemHandler extends AbstractHandler {
     requiredParametersCount = 2
@@ -11,7 +10,7 @@ class ArrayGetItemHandler extends AbstractHandler {
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Array Get Item parameters mismatch")
+                throw new Error('Array Get Item parameters mismatch')
             }
             let array = command.payload[0]
             let indexes
@@ -36,4 +35,4 @@ class ArrayGetItemHandler extends AbstractHandler {
     }
 }
 
-module.exports = new ArrayGetItemHandler()
+module.exports = new ArrayGetItemHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/ArrayGetRankHandler.js

@@ -1,8 +1,6 @@
-const AbstractHandler = require("./AbstractHandler")
-
+const AbstractHandler = require('./AbstractHandler')
 
 class ArrayGetRankHandler extends AbstractHandler {
-
     requiredParametersCount = 1
 
     constructor() {
@@ -11,12 +9,12 @@ class ArrayGetRankHandler extends AbstractHandler {
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Array Get Rank parameters mismatch")
+                throw new Error('Array Get Rank parameters mismatch')
             }
             let array = command.payload[0]
             let rank = 0
-            while(Array.isArray(array)) {
-                rank = rank +1
+            while (Array.isArray(array)) {
+                rank = rank + 1
                 array = array[0]
             }
 
@@ -27,4 +25,4 @@ class ArrayGetRankHandler extends AbstractHandler {
     }
 }
 
-module.exports = new ArrayGetRankHandler()
+module.exports = new ArrayGetRankHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/ArrayGetSizeHandler.js

@@ -1,5 +1,4 @@
-const AbstractHandler = require("./AbstractHandler")
-
+const AbstractHandler = require('./AbstractHandler')
 
 class ArrayGetSizeHandler extends AbstractHandler {
     requiredParametersCount = 1
@@ -11,7 +10,7 @@ class ArrayGetSizeHandler extends AbstractHandler {
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Array Get Size parameters mismatch")
+                throw new Error('Array Get Size parameters mismatch')
             }
             let array = command.payload[0]
             let size = 1
@@ -27,4 +26,4 @@ class ArrayGetSizeHandler extends AbstractHandler {
     }
 }
 
-module.exports = new ArrayGetSizeHandler()
+module.exports = new ArrayGetSizeHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/ArrayHandler.js

@@ -1,5 +1,4 @@
-const AbstractHandler = require("./AbstractHandler")
-
+const AbstractHandler = require('./AbstractHandler')
 
 class ArrayHandler extends AbstractHandler {
     constructor() {
@@ -16,4 +15,4 @@ class ArrayHandler extends AbstractHandler {
     }
 }
 
-module.exports = new ArrayHandler()
+module.exports = new ArrayHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/ArraySetItemHandler.js

@@ -1,5 +1,4 @@
-const AbstractHandler = require("./AbstractHandler")
-
+const AbstractHandler = require('./AbstractHandler')
 
 class ArraySetItemHandler extends AbstractHandler {
     requiredParametersCount = 3
@@ -11,7 +10,7 @@ class ArraySetItemHandler extends AbstractHandler {
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Array Set Item parameters mismatch")
+                throw new Error('Array Set Item parameters mismatch')
             }
 
             let array = command.payload[0]
@@ -34,11 +33,11 @@ class ArraySetItemHandler extends AbstractHandler {
                 array[indexes[indexes.length - 1]] = value
             }
 
-            return 0;
+            return 0
         } catch (error) {
             throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }
 
-module.exports = new ArraySetItemHandler()
+module.exports = new ArraySetItemHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/CastingHandler.js

@@ -1,10 +1,10 @@
-const AbstractHandler = require("./AbstractHandler")
-
+const AbstractHandler = require('./AbstractHandler')
 
 class CastingHandler extends AbstractHandler {
+    // eslint-disable-next-line no-unused-vars
     process(command) {
         throw new Error(`Dynamically typed languages are not supporting casting`)
     }
 }
 
-module.exports = new CastingHandler()
+module.exports = new CastingHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/CreateClassInstanceHandler.js

@@ -0,0 +1,36 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class CreateClassInstanceHandler extends AbstractHandler {
+    requiredParametersCount = 1
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Create Class Instance parameters mismatch')
+            }
+            let clazz = command.payload[0]
+            let constructorArguments = command.payload.slice(1)
+            let instance = new clazz(...constructorArguments)
+            if (typeof instance === 'undefined') {
+                let methods = Object.getOwnPropertyNames(type).filter(function (property) {
+                    return typeof type[property] === 'function'
+                })
+                let message = `Method 'constructor' not found in class. Available methods:\n`
+                methods.forEach((methodIter) => {
+                    message += `${methodIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return instance
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new CreateClassInstanceHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/DestructReferenceHandler.js

@@ -1,8 +1,7 @@
-const AbstractHandler = require("./AbstractHandler");
-const ReferencesCache = require("../referenceCache/ReferencesCache")
+const ReferencesCache = require('../referenceCache/ReferencesCache')
+const AbstractHandler = require('./AbstractHandler')
 
 class DestructReferenceHandler extends AbstractHandler {
-
     constructor() {
         super()
     }
@@ -17,4 +16,4 @@ class DestructReferenceHandler extends AbstractHandler {
     }
 }
 
-module.exports = new DestructReferenceHandler()
+module.exports = new DestructReferenceHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/EnableNamespaceHandler.js

@@ -1,8 +1,7 @@
-const AbstractHandler = require("./AbstractHandler");
-const NamespaceCache = require("../namespaceCache/NamespaceCache");
+const NamespaceCache = require('../namespaceCache/NamespaceCache')
+const AbstractHandler = require('./AbstractHandler')
 
 class EnableNamespaceHandler extends AbstractHandler {
-
     constructor() {
         super()
         this.requiredParametersCount = 1
@@ -11,27 +10,25 @@ class EnableNamespaceHandler extends AbstractHandler {
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
-                throw new Error(this.constructor.name + " parameters mismatch")
+                throw new Error(this.constructor.name + ' parameters mismatch')
             }
-            const namespace_cache = new NamespaceCache();
+            const namespace_cache = new NamespaceCache()
 
             for (let payload of command.payload) {
                 if (typeof payload === 'string') {
-                    namespace_cache.cacheNamespace(payload);
+                    namespace_cache.cacheNamespace(payload)
                 }
                 if (Array.isArray(payload)) {
                     for (let namespace_to_enable of payload) {
-                        namespace_cache.cacheNamespace(namespace_to_enable);
+                        namespace_cache.cacheNamespace(namespace_to_enable)
                     }
                 }
             }
-            return 0;
-
+            return 0
         } catch (error) {
             throw this.process_stack_trace(error, this.constructor.name)
         }
-
     }
 }
 
-module.exports = new EnableNamespaceHandler()
+module.exports = new EnableNamespaceHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/EnableTypeHandler.js

@@ -1,5 +1,5 @@
-const AbstractHandler = require("./AbstractHandler");
-const TypeCache = require("../typeCache/TypeCache");
+const TypeCache = require('../typeCache/TypeCache')
+const AbstractHandler = require('./AbstractHandler')
 
 class EnableTypeHandler extends AbstractHandler {
     requiredParametersCount = 1
@@ -11,27 +11,25 @@ class EnableTypeHandler extends AbstractHandler {
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Get Type parameters mismatch")
+                throw new Error('Get Type parameters mismatch')
             }
-            const typeCache = new TypeCache();
+            const typeCache = new TypeCache()
 
             for (let payload of command.payload) {
                 if (typeof payload === 'string') {
-                    typeCache.cacheType(payload);
+                    typeCache.cacheType(payload)
                 }
                 if (Array.isArray(payload)) {
                     for (let namespace_to_enable of payload) {
-                        typeCache.cacheType(namespace_to_enable);
+                        typeCache.cacheType(namespace_to_enable)
                     }
                 }
             }
-            return 0;
-
+            return 0
         } catch (error) {
             throw this.process_stack_trace(error, this.constructor.name)
         }
-
     }
 }
 
-module.exports = new EnableTypeHandler()
+module.exports = new EnableTypeHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/GetGlobalStaticFieldHandler.js

@@ -0,0 +1,37 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class GetGlobalStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount = 1
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Get global static field parameters mismatch')
+            }
+            const { payload } = command
+            const splitted = payload[0].split('.')
+            let fieldToGet
+
+            for (let i = 0; i < splitted.length; i++) {
+                fieldToGet = !fieldToGet ? global[splitted[i]] : fieldToGet[splitted[i]]
+                if (typeof fieldToGet === 'undefined') {
+                    let fields = Object.keys(global)
+                    let message = `Field ${payload[0]} not found in global. Available fields:\n`
+                    fields.forEach((fieldIter) => {
+                        message += `${fieldIter}\n`
+                    })
+                    throw new Error(message)
+                }
+            }
+            return fieldToGet
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new GetGlobalStaticFieldHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/GetInstanceFieldHandler.js

@@ -0,0 +1,35 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class GetInstanceFieldHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Get Instance Field parameters mismatch')
+            }
+            const { payload } = command
+            let instance = payload[0]
+            let field = payload[1]
+            let instanceField = instance[field]
+            if (typeof instanceField === 'undefined') {
+                let fields = Object.keys(instance)
+                let message = `Field ${field} not found in object. Available fields:\n`
+                fields.forEach((fieldIter) => {
+                    message += `${fieldIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return instanceField
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new GetInstanceFieldHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/GetStaticFieldHandler.js

@@ -0,0 +1,36 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class GetStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Array Static Field parameters mismatch')
+            }
+            const { payload } = command
+            let type = payload[0]
+            let field = payload[1]
+
+            let staticField = type[field]
+            if (typeof staticField === 'undefined') {
+                let fields = Object.keys(type)
+                let message = `Field ${field} not found in class. Available fields:\n`
+                fields.forEach((fieldIter) => {
+                    message += `${fieldIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return staticField
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new GetStaticFieldHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/GetTypeHandler.js

@@ -0,0 +1,63 @@
+const AbstractHandler = require('./AbstractHandler')
+const LoadLibraryHandler = require('./LoadLibraryHandler')
+const NamespaceCache = require('../namespaceCache/NamespaceCache')
+const TypeCache = require('../typeCache/TypeCache')
+
+class GetTypeHandler extends AbstractHandler {
+    constructor() {
+        super()
+        this.requiredParametersCount = 1
+        this.namespaceCache = new NamespaceCache()
+        this.typeCache = new TypeCache()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Get Type parameters mismatch')
+            }
+            const { payload } = command
+            let typeName = payload[0]
+            typeName = typeName.replace('.js', '')
+            let typeToReturn = global[typeName]
+            if (typeToReturn === undefined) {
+                let message = `Type ${typeName} not found\n`
+                message += 'Available types:\n'
+                message += this.getAvailableTypes().join('\n')
+                throw new Error(message)
+            }
+
+            if (
+                (this.namespaceCache.isNamespaceCacheEmpty() && this.typeCache.isTypeCacheEmpty()) || // both caches are empty
+                this.namespaceCache.isTypeAllowed(typeToReturn) || // namespace is allowed
+                this.typeCache.isTypeAllowed(typeToReturn) // type is allowed
+            ) {
+                // continue - type is allowed
+            } else {
+                let allowed_namespaces = this.namespaceCache.getCachedNamespaces().join(', ')
+                let allowed_types = this.typeCache.getCachedTypes().join(', ')
+                throw new Error(
+                    `Type ${typeToReturn.name} not allowed. \nAllowed namespaces: ${allowed_namespaces}\nAllowed types: ${allowed_types}`
+                )
+            }
+
+            return typeToReturn
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+
+    getAvailableTypes() {
+        let availableTypes = []
+        LoadLibraryHandler.getLoadedLibraries().forEach((lib) => {
+            const moduleExports = require(lib)
+            availableTypes.push(moduleExports.name)
+            Object.keys(moduleExports).forEach((key) => {
+                availableTypes.push(key)
+            })
+        })
+        return availableTypes
+    }
+}
+
+module.exports = new GetTypeHandler()