javonet-ruby-sdk 2.1.13 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af16c667c0296d6b9ee4be30b0fad325f1653043368b4daeb3d28218afd8198f
-  data.tar.gz: 3333d1f0ac31263b974bce7ea80f14da47c54d3fd6b96827618cd29977bc7a7a
+  metadata.gz: f4c474b0816bcd19fa3d3c0f060cbe5f8d783e3e3513a874639ee3d20237940e
+  data.tar.gz: 5e674a6ebe5a564554b396fc6a169a4c50bd4dd91d9ee798ee85a8fc37de1ba2
 SHA512:
-  metadata.gz: eefc0169f92a585c825165337d5361ab8a3abec003a3172d0360aac8d80b8ab98d416312e835a64d21c604c9c0bca32d726e90e7a0d80a7fe128be74c67d5766
-  data.tar.gz: 06750a356dda0e9c81a174aa199f147e9f8f87ee688863a0f6824e2dfe8ff09d411bbcfd8db95fcfe7dbfdf27a4d93cf072800fe5103b8b651622063ba896c05
+  metadata.gz: 8ff06ae9071707d424ce7491f53d2d0b25d78006525f7f40e91ca35642cb85d0b84db449e08239e9deb952a5288a8140f86bdc7da9eb386d5c8dc4cd8529d6f9
+  data.tar.gz: 14712bd14b1e88a372880fac05ef22fa4e536ea26775833fc858c31841542558e733fb4fb00b6d453da3b18ed31c99f5e3f1fedf6a0ac4719eeccd283b8b5281

data/VERSION

@@ -1 +1 @@
-2.1.13
+2.2.0

data/lib/javonet-ruby-sdk/Binaries/Native/Linux/X64/version.txt

@@ -0,0 +1 @@
+2.2.0

data/lib/javonet-ruby-sdk/Binaries/Native/MacOs/X64/version.txt

@@ -0,0 +1 @@
+2.2.0

data/lib/javonet-ruby-sdk/Binaries/Native/Windows/X64/version.txt

@@ -0,0 +1 @@
+'2.2.0' 

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

@@ -1,29 +1,38 @@
 const AbstractHandler = require("./AbstractHandler");
 
 class CreateClassInstanceHandler extends AbstractHandler {
-    requiredParametersCount = 1
+  requiredParametersCount = 1;
 
-    constructor() {
-        super()
-    }
+  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') {
-                throw "Instance cannot be created"
-            } else {
-                return instance
-            }
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+  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()
+module.exports = new CreateClassInstanceHandler();

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

@@ -1,30 +1,39 @@
-const AbstractHandler = require("./AbstractHandler")
+const AbstractHandler = require("./AbstractHandler");
 
 class GetGlobalStaticFieldHandler extends AbstractHandler {
-    requiredParametersCount = 1
+  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
+  constructor() {
+    super();
+  }
 
-            for (let i = 0; i < splitted.length; i++) {
-                fieldToGet = !fieldToGet ? global[splitted[i]] : fieldToGet[splitted[i]]
-            }
-            return fieldToGet
+  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;
 
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
+      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()
+module.exports = new GetGlobalStaticFieldHandler();

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

@@ -1,30 +1,35 @@
 const AbstractHandler = require("./AbstractHandler");
 
 class GetInstanceFieldHandler extends AbstractHandler {
-    requiredParametersCount = 2
+  requiredParametersCount = 2;
 
-    constructor() {
-        super()
-    }
+  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') {
-                throw new Error("Instance field does not exist")
-            } else {
-                return instanceField
-            }
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+  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()
+module.exports = new GetInstanceFieldHandler();

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

@@ -1,32 +1,36 @@
 const AbstractHandler = require("./AbstractHandler");
 
 class GetStaticFieldHandler extends AbstractHandler {
-    requiredParametersCount = 2
+  requiredParametersCount = 2;
 
-    constructor() {
-        super()
-    }
+  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]
+  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') {
-                throw new Error("Static field does not exist")
-            } else {
-                return staticField
-            }
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+      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()
+module.exports = new GetStaticFieldHandler();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/handler/InvokeGlobalMethodHandler.js

@@ -1,36 +1,47 @@
 const AbstractHandler = require("./AbstractHandler");
 
 class InvokeGlobalMethodHandler extends AbstractHandler {
-    requiredParametersCount = 1
+  requiredParametersCount = 1;
 
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Invoke Global Method parameters mismatch")
-            }
-            const {payload} = command
-            const splitted = payload[0].split(".")
-            let methodToInvoke
-            for (let i = 0; i < splitted.length; i++) {
-                methodToInvoke = !methodToInvoke ? global[splitted[i]] : methodToInvoke[splitted[i]]
-            }
-            if (payload.length > 1) {
-                const args = payload.slice(1)
-                return methodToInvoke(args)
-            } else {
-                return methodToInvoke()
-            }
+  constructor() {
+    super();
+  }
 
-
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Invoke Global Method parameters mismatch");
+      }
+      const { payload } = command;
+      const splitted = payload[0].split(".");
+      let methodToInvoke;
+      for (let i = 0; i < splitted.length; i++) {
+        methodToInvoke = !methodToInvoke
+          ? global[splitted[i]]
+          : methodToInvoke[splitted[i]];
+      }
+      if (typeof methodToInvoke === "undefined") {
+        let methods = Object.getOwnPropertyNames(global).filter(function (
+          property
+        ) {
+          return typeof global[property] === "function";
+        });
+        let message = `Method ${payload[0]} not found in global. Available methods:\n`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}\n`;
+        });
+        throw new Error(message);
+      }
+      if (payload.length > 1) {
+        const args = payload.slice(1);
+        return methodToInvoke(args);
+      } else {
+        return methodToInvoke();
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
     }
-
+  }
 }
 
-module.exports = new InvokeGlobalMethodHandler()
+module.exports = new InvokeGlobalMethodHandler();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/handler/InvokeInstanceMethodHandler.js

@@ -1,32 +1,40 @@
 const AbstractHandler = require("./AbstractHandler");
 
 class InvokeInstanceMethodHandler extends AbstractHandler {
-    requiredParametersCount = 2
+  requiredParametersCount = 2;
 
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Invoke Instance Method parameters mismatch")
-            }
-            const {payload} = command
-            let instance = payload[0]
-            let methodName = payload[1]
-            let args = payload.slice(2)
-            let method = instance[methodName]
-            if (typeof (method) === 'undefined') {
-                throw new Error("Instance method does not exist")
-            } else {
-                return Reflect.apply(instance[methodName], undefined, args)
-            }
+  constructor() {
+    super();
+  }
 
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Invoke Instance Method parameters mismatch");
+      }
+      const { payload } = command;
+      let instance = payload[0];
+      let methodName = payload[1];
+      let args = payload.slice(2);
+      let method = instance[methodName];
+      if (typeof method === "undefined") {
+        let methods = Object.getOwnPropertyNames(instance.__proto__).filter(
+          function (property) {
+            return typeof instance.__proto__[property] === "function";
+          }
+        );
+        let message = `Method ${methodName} not found in object. Available methods:\n`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}\n`;
+        });
+        throw new Error(message);
+      } else {
+        return Reflect.apply(method, instance, args);
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
     }
+  }
 }
 
-module.exports = new InvokeInstanceMethodHandler()
+module.exports = new InvokeInstanceMethodHandler();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/handler/InvokeStaticMethodHandler.js

@@ -1,31 +1,40 @@
-const AbstractHandler = require('./AbstractHandler')
+const AbstractHandler = require("./AbstractHandler");
 
 class InvokeStaticMethodHandler extends AbstractHandler {
-    requiredParametersCount = 2
+  requiredParametersCount = 2;
 
-    constructor() {
-        super()
-    }
+  constructor() {
+    super();
+  }
 
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Invoke Static Method parameters mismatch")
-            }
-            const {payload} = command
-            let type = payload[0]
-            let methodName = payload[1]
-            let args = payload.slice(2)
-            let method = type[methodName]
-            if (typeof (method) === 'undefined') {
-                throw new Error("Static method does not exist")
-            } else {
-                return Reflect.apply(method, undefined, args)
-            }
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Invoke Static Method parameters mismatch");
+      }
+      const { payload } = command;
+      let type = payload[0];
+      let methodName = payload[1];
+      let args = payload.slice(2);
+      let method = type[methodName];
+      if (typeof method === "undefined") {
+        let methods = Object.getOwnPropertyNames(type).filter(function (
+          property
+        ) {
+          return typeof type[property] === "function";
+        });
+        let message = `Method ${methodName} not found in class. Available methods:\n`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}\n`;
+        });
+        throw new Error(message);
+      } else {
+        return Reflect.apply(method, undefined, args);
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
     }
+  }
 }
 
-module.exports = new InvokeStaticMethodHandler()
+module.exports = new InvokeStaticMethodHandler();