js: transfer encoding changes

--

* Uint8Arrays are not supported for now there are unsolved issues in
  conversion, and they are lower priority

* encrypt gains a new option to indicate that input values are base64
  encoded
* as decrypted values are always base64 encoded, the option base64 will
  not try to decode the result into utf, but leave it as it is

4 files changed, 52 insertions, 42 deletions

diff --git a/lang/js/src/Connection.js b/lang/js/src/Connection.js
index 1931a55b..9c2a6428 100644
--- a/lang/js/src/Connection.js
+++ b/lang/js/src/Connection.js
@@ -93,7 +93,7 @@ export class Connection{
         }
         let me = this;
         return new Promise(function(resolve, reject){
-            let answer = new Answer(message.operation);
+            let answer = new Answer(message);
             let listener = function(msg) {
                 if (!msg){
                     me._connection.onMessage.removeListener(listener)
@@ -147,8 +147,9 @@ export class Connection{
  */
 class Answer{
 
-    constructor(operation){
-        this.operation = operation;
+    constructor(message){
+        this.operation = message.operation;
+        this.expected = message.expected;
     }
 
     /**
@@ -210,26 +211,31 @@ class Answer{
     }
 
     /**
-     * @returns {Object} the assembled message.
-     * TODO: does not care yet if completed.
+     * @returns {Object} the assembled message, original data assumed to be
+     * (javascript-) strings
      */
     get message(){
         let keys = Object.keys(this._response);
+        let msg = {};
         let poa = permittedOperations[this.operation].answer;
         for (let i=0; i < keys.length; i++) {
-            if (poa.data.indexOf(keys[i]) >= 0){
-                if (this._response.base64 == true){
-                    let respatob =  atob(this._response[keys[i]]);
-
-                    let result = decodeURIComponent(
-                        respatob.split('').map(function(c) {
+            if (poa.data.indexOf(keys[i]) >= 0
+                && this._response.base64 === true
+            ) {
+                msg[keys[i]] = atob(this._response[keys[i]]);
+                if (this.expected === 'base64'){
+                    msg[keys[i]] = this._response[keys[i]];
+                } else {
+                    msg[keys[i]] = decodeURIComponent(
+                        atob(this._response[keys[i]]).split('').map(function(c) {
                             return '%' +
-                            ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+                                ('00' + c.charCodeAt(0).toString(16)).slice(-2);
                         }).join(''));
-                    this._response[keys[i]] = result;
                 }
+            } else {
+                msg[keys[i]] = this._response[keys[i]];
             }
         }
-        return this._response;
+        return msg;
     }
 }
diff --git a/lang/js/src/Message.js b/lang/js/src/Message.js
index 6a59c3e0..932212a6 100644
--- a/lang/js/src/Message.js
+++ b/lang/js/src/Message.js
@@ -41,6 +41,7 @@ export class GPGME_Message {
 
     constructor(operation){
         this.operation = operation;
+        this._expected = 'string';
     }
 
     set operation (op){
@@ -58,6 +59,19 @@ export class GPGME_Message {
         return this._msg.op;
     }
 
+    set expected(string){
+        if (string === 'base64'){
+            this._expected = 'base64';
+        }
+    }
+
+    get expected() {
+       if (this._expected === "base64"){
+           return this._expected;
+       }
+       return "string";
+    }
+
     /**
      * Sets a parameter for the message. Note that the operation has to be set
      * first, to be able to check if the parameter is permittted
diff --git a/lang/js/src/gpgmejs.js b/lang/js/src/gpgmejs.js
index d106f4f7..01cb92c3 100644
--- a/lang/js/src/gpgmejs.js
+++ b/lang/js/src/gpgmejs.js
@@ -64,11 +64,11 @@ export class GpgME {
     }
 
     /**
-     * @param {String|Uint8Array} data text/data to be encrypted as String/Uint8Array
+     * @param {String} data text/data to be encrypted as String
      * @param  {GPGME_Key|String|Array<String>|Array<GPGME_Key>} publicKeys Keys used to encrypt the message
      * @param {Boolean} wildcard (optional) If true, recipient information will not be added to the message
      */
-    encrypt(data, publicKeys, wildcard=false){
+    encrypt(data, publicKeys, base64=false, wildcard=false){
 
         let msg = createMessage('encrypt');
         if (msg instanceof Error){
@@ -77,11 +77,14 @@ export class GpgME {
         // TODO temporary
         msg.setParameter('armor', true);
         msg.setParameter('always-trust', true);
-
+        if (base64 === true) {
+            msg.setParameter('base64', true);
+        }
         let pubkeys = toKeyIdArray(publicKeys);
         msg.setParameter('keys', pubkeys);
         putData(msg, data);
-        if (wildcard === true){msg.setParameter('throw-keyids', true);
+        if (wildcard === true){
+            msg.setParameter('throw-keyids', true);
         };
         if (msg.isComplete === true){
             return this.connection.post(msg);
@@ -91,7 +94,8 @@ export class GpgME {
     }
 
     /**
-    * @param  {String} data TODO Format: base64? String? Message with the encrypted data
+    * @param  {String} data TODO base64? Message with the encrypted data
+    * @param {Boolean} base64 (optional) Response should stay base64
     * @returns {Promise<Object>} decrypted message:
         data:   The decrypted data.  This may be base64 encoded.
         base64: Boolean indicating whether data is base64 encoded.
@@ -100,11 +104,14 @@ export class GpgME {
     * @async
     */
 
-    decrypt(data){
+    decrypt(data, base64=false){
         if (data === undefined){
             return Promise.reject(gpgme_error('MSG_EMPTY'));
         }
         let msg = createMessage('decrypt');
+        if (base64 === true){
+            msg.expected = 'base64';
+        }
         if (msg instanceof Error){
             return Promise.reject(msg);
         }
@@ -156,11 +163,9 @@ export class GpgME {
 }
 
 /**
- * Sets the data of the message, converting Uint8Array to base64 and setting
- * the base64 flag
+ * Sets the data of the message
  * @param {GPGME_Message} message The message where this data will be set
  * @param {*} data The data to enter
- * @param {String} propertyname // TODO unchecked still
  */
 function putData(message, data){
     if (!message || !message instanceof GPGME_Message ) {
@@ -168,30 +173,15 @@ function putData(message, data){
     }
     if (!data){
         return gpgme_error('PARAM_WRONG');
-    } else if (data instanceof Uint8Array){
-        message.setParameter('base64', true);
-        // TODO: btoa turns the array into a string
-        // of comma separated  of numbers
-        // atob(data).split(',') would result in a "normal" array of numbers
-        // atob(btoa(data)).split(',') would result in a "normal" array of numbers
-        // would result in a "normal" array of numbers
-        message.setParameter ('data', btoa(data));
-
     } else if (typeof(data) === 'string') {
-        message.setParameter('base64', false);
         message.setParameter('data', data);
     } else if (
         typeof(data) === 'object' &&
         typeof(data.getText) === 'function'
     ){
         let txt = data.getText();
-        if (txt instanceof Uint8Array){
-            message.setParameter('base64', true);
-            message.setParameter ('data', btoa(txt));
-        }
-        else if (typeof(txt) === 'string'){
-            message.setParameter('base64', false);
-            message.setParameter ('data', txt);
+        if (typeof(txt) === 'string'){
+            message.setParameter('data', txt);
         } else {
             return gpgme_error('PARAM_WRONG');
         }
diff --git a/lang/js/src/permittedOperations.js b/lang/js/src/permittedOperations.js
index 59597aaf..da46a1fd 100644
--- a/lang/js/src/permittedOperations.js
+++ b/lang/js/src/permittedOperations.js
@@ -51,7 +51,7 @@ export const permittedOperations = {
                 array_allowed: true
             },
             'data': {
-                allowed: ['string', 'Uint8Array']
+                allowed: ['string']
             }
         },
         optional: {
@@ -103,7 +103,7 @@ export const permittedOperations = {
         pinentry: true,
         required: {
             'data': {
-                allowed: ['string', 'Uint8Array']
+                allowed: ['string']
             }
         },
         optional: {