js: revert changes to class read/write restriction

--

* undoes 94ee0988d4eaac27785de6efb7c19ca9976e1e9c and
  e16a87e83910ebb6bfdc4148369165f121f0997e.
  I do not fully understand why my approach was bad, but I am not in
  a position to argue. This revert was requested to me after a review,
  and I'm doing it in the assumption that more experienced people know
  better than me.
* unittests: Also changed some outdated tests that stopped working
  since 754e799d35fd62d7a979452f44342934659908c7 (as GPGME_Key is not
  exported, one cannot check for instanceof in the tests anymore)

1 files changed, 204 insertions, 221 deletions

diff --git a/lang/js/src/gpgmejs.js b/lang/js/src/gpgmejs.js
index 18164366..4aa51759 100644
--- a/lang/js/src/gpgmejs.js
+++ b/lang/js/src/gpgmejs.js
@@ -85,243 +85,226 @@ import { createSignature } from './Signature';
 export class GpgME {
 
     constructor(){
-        let _Keyring = null;
-
-        /**
-         * Sets a new Keyring to be used
-         * @param {GPGME_Keyring} keyring
-         */
-        this.setKeyring = function(keyring){
-            if (keyring && keyring instanceof GPGME_Keyring){
-                _Keyring = keyring;
-            }
-        };
+        this._Keyring = null;
+    }
 
-        /**
-         * Accesses the {@link GPGME_Keyring}.
-         */
-        this.getKeyring = function(){
-            if (!_Keyring){
-                _Keyring = Object.freeze(new GPGME_Keyring);
-            }
-            return _Keyring;
-        };
+    /**
+     * setter for {@link setKeyring}.
+     * @param {GPGME_Keyring} keyring A Keyring to use
+     */
+    set Keyring(keyring){
+        if (keyring && keyring instanceof GPGME_Keyring){
+            this._Keyring = keyring;
+        }
+    }
+    /**
+     * Accesses the {@link GPGME_Keyring}.
+     */
+    get Keyring(){
+        if (!this._Keyring){
+            this._Keyring = new GPGME_Keyring;
+        }
+        return this._Keyring;
+    }
 
-        /**
-         * Encrypt (and optionally sign) data
-         * @param {String|Object} data text/data to be encrypted as String. Also
-         * accepts Objects with a getText method
-         * @param {inputKeys} publicKeys
-         * Keys used to encrypt the message
-         * @param {inputKeys} secretKeys (optional) Keys used to sign the
-         * message. If Keys are present, the  operation requested is assumed
-         * to be 'encrypt and sign'
-         * @param {Boolean} base64 (optional) The data will be interpreted as
-         * base64 encoded data.
-         * @param {Boolean} armor (optional) Request the output as armored
-         * block.
-         * @param {Boolean} wildcard (optional) If true, recipient information
-         * will not be added to the message.
-         * @param {Object} additional use additional valid gpg options as
-         * defined in {@link permittedOperations}
-         * @returns {Promise<encrypt_result>} Object containing the encrypted
-         * message and additional info.
-         * @async
-         */
-        this.encrypt = function (data, publicKeys, secretKeys, base64=false,
-            armor=true, wildcard=false, additional = {}
-        ){
-            let msg = createMessage('encrypt');
-            if (msg instanceof Error){
-                return Promise.reject(msg);
-            }
-            msg.setParameter('armor', armor);
-            msg.setParameter('always-trust', true);
-            if (base64 === true) {
-                msg.setParameter('base64', true);
-            }
-            let pubkeys = toKeyIdArray(publicKeys);
-            msg.setParameter('keys', pubkeys);
-            let sigkeys = toKeyIdArray(secretKeys);
-            if (sigkeys.length > 0) {
-                msg.setParameter('signing_keys', sigkeys);
-            }
-            putData(msg, data);
-            if (wildcard === true){
-                msg.setParameter('throw-keyids', true);
-            }
-            if (additional){
-                let additional_Keys = Object.keys(additional);
-                for (let k = 0; k < additional_Keys.length; k++) {
-                    msg.setParameter(additional_Keys[k],
-                        additional[additional_Keys[k]]);
-                }
-            }
-            if (msg.isComplete() === true){
-                return msg.post();
-            } else {
-                return Promise.reject(gpgme_error('MSG_INCOMPLETE'));
+    /**
+     * Encrypt (and optionally sign) data
+     * @param {String|Object} data text/data to be encrypted as String. Also
+     * accepts Objects with a getText method
+     * @param {inputKeys} publicKeys
+     * Keys used to encrypt the message
+     * @param {inputKeys} secretKeys (optional) Keys used to sign the
+     * message. If Keys are present, the  operation requested is assumed
+     * to be 'encrypt and sign'
+     * @param {Boolean} base64 (optional) The data will be interpreted as
+     * base64 encoded data.
+     * @param {Boolean} armor (optional) Request the output as armored
+     * block.
+     * @param {Boolean} wildcard (optional) If true, recipient information
+     * will not be added to the message.
+     * @param {Object} additional use additional valid gpg options as
+     * defined in {@link permittedOperations}
+     * @returns {Promise<encrypt_result>} Object containing the encrypted
+     * message and additional info.
+     * @async
+     */
+    encrypt (data, publicKeys, secretKeys, base64=false, armor=true,
+        wildcard=false, additional = {}){
+        let msg = createMessage('encrypt');
+        if (msg instanceof Error){
+            return Promise.reject(msg);
+        }
+        msg.setParameter('armor', armor);
+        msg.setParameter('always-trust', true);
+        if (base64 === true) {
+            msg.setParameter('base64', true);
+        }
+        let pubkeys = toKeyIdArray(publicKeys);
+        msg.setParameter('keys', pubkeys);
+        let sigkeys = toKeyIdArray(secretKeys);
+        if (sigkeys.length > 0) {
+            msg.setParameter('signing_keys', sigkeys);
+        }
+        putData(msg, data);
+        if (wildcard === true){
+            msg.setParameter('throw-keyids', true);
+        }
+        if (additional){
+            let additional_Keys = Object.keys(additional);
+            for (let k = 0; k < additional_Keys.length; k++) {
+                msg.setParameter(additional_Keys[k],
+                    additional[additional_Keys[k]]);
             }
-        };
+        }
+        if (msg.isComplete() === true){
+            return msg.post();
+        } else {
+            return Promise.reject(gpgme_error('MSG_INCOMPLETE'));
+        }
+    }
 
-        /**
-        * Decrypts a Message
-        * @param {String|Object} data text/data to be decrypted. Accepts
-        * Strings and Objects with a getText method
-        * @param {Boolean} base64 (optional) false if the data is an armored
-        * block, true if it is base64 encoded binary data
-        * @returns {Promise<decrypt_result>} Decrypted Message and information
-        * @async
-        */
-        this.decrypt = function (data, base64=false){
-            if (data === undefined){
-                return Promise.reject(gpgme_error('MSG_EMPTY'));
-            }
-            let msg = createMessage('decrypt');
+    /**
+    * Decrypts a Message
+    * @param {String|Object} data text/data to be decrypted. Accepts
+    * Strings and Objects with a getText method
+    * @param {Boolean} base64 (optional) false if the data is an armored
+    * block, true if it is base64 encoded binary data
+    * @returns {Promise<decrypt_result>} Decrypted Message and information
+    * @async
+    */
+    decrypt (data, base64=false){
+        if (data === undefined){
+            return Promise.reject(gpgme_error('MSG_EMPTY'));
+        }
+        let msg = createMessage('decrypt');
 
-            if (msg instanceof Error){
-                return Promise.reject(msg);
-            }
-            if (base64 === true){
-                msg.setParameter('base64', true);
-            }
-            putData(msg, data);
-            if (base64 === true){
-                msg.setParameter('base64', true);
-            }
-            return new Promise(function(resolve, reject){
-                msg.post().then(function(result){
-                    let _result = {data: result.data};
-                    _result.base64 = result.base64 ? true: false;
-                    _result.is_mime = result.is_mime ? true: false;
-                    if (result.file_name){
-                        _result.file_name = result.file_name;
-                    } else {
-                        _result.file_name = null;
-                    }
-                    if (
-                        result.hasOwnProperty('signatures') &&
-                        Array.isArray(result.signatures)
-                    ) {
-                        _result.signatures = collectSignatures(
-                            result.signatures);
-                    }
-                    resolve(_result);
-                }, function(error){
-                    reject(error);
-                });
+        if (msg instanceof Error){
+            return Promise.reject(msg);
+        }
+        if (base64 === true){
+            msg.setParameter('base64', true);
+        }
+        putData(msg, data);
+        if (base64 === true){
+            msg.setParameter('base64', true);
+        }
+        return new Promise(function(resolve, reject){
+            msg.post().then(function(result){
+                let _result = {data: result.data};
+                _result.base64 = result.base64 ? true: false;
+                _result.is_mime = result.is_mime ? true: false;
+                if (result.file_name){
+                    _result.file_name = result.file_name;
+                } else {
+                    _result.file_name = null;
+                }
+                if (
+                    result.hasOwnProperty('signatures') &&
+                    Array.isArray(result.signatures)
+                ) {
+                    _result.signatures = collectSignatures(
+                        result.signatures);
+                }
+                resolve(_result);
+            }, function(error){
+                reject(error);
             });
-        };
+        });
+    }
 
-        /**
-         * Sign a Message
-         * @param {String|Object} data text/data to be signed. Accepts Strings
-         * and Objects with a getText method.
-         * @param {inputKeys} keys The key/keys to use for signing
-         * @param {String} mode The signing mode. Currently supported:
-         *  'clearsign':The Message is embedded into the signature;
-         *  'detached': The signature is stored separately
-         * @param {Boolean} base64 input is considered base64
-         * @returns {Promise<signResult>}
-         * @async
-         */
-        this.sign = function (data, keys, mode='clearsign', base64=false) {
-            if (data === undefined){
-                return Promise.reject(gpgme_error('MSG_EMPTY'));
-            }
-            let key_arr = toKeyIdArray(keys);
-            if (key_arr.length === 0){
-                return Promise.reject(gpgme_error('MSG_NO_KEYS'));
-            }
-            let msg = createMessage('sign');
+    /**
+     * Sign a Message
+     * @param {String|Object} data text/data to be signed. Accepts Strings
+     * and Objects with a getText method.
+     * @param {inputKeys} keys The key/keys to use for signing
+     * @param {String} mode The signing mode. Currently supported:
+     *  'clearsign':The Message is embedded into the signature;
+     *  'detached': The signature is stored separately
+     * @param {Boolean} base64 input is considered base64
+     * @returns {Promise<signResult>}
+     * @async
+     */
+    sign (data, keys, mode='clearsign', base64=false) {
+        if (data === undefined){
+            return Promise.reject(gpgme_error('MSG_EMPTY'));
+        }
+        let key_arr = toKeyIdArray(keys);
+        if (key_arr.length === 0){
+            return Promise.reject(gpgme_error('MSG_NO_KEYS'));
+        }
+        let msg = createMessage('sign');
 
-            msg.setParameter('keys', key_arr);
-            if (base64 === true){
-                msg.setParameter('base64', true);
+        msg.setParameter('keys', key_arr);
+        if (base64 === true){
+            msg.setParameter('base64', true);
+        }
+        msg.setParameter('mode', mode);
+        putData(msg, data);
+        return new Promise(function(resolve,reject) {
+            if (mode ==='detached'){
+                msg.expected ='base64';
             }
-            msg.setParameter('mode', mode);
-            putData(msg, data);
-            return new Promise(function(resolve,reject) {
-                if (mode ==='detached'){
-                    msg.setExpect('base64');
+            msg.post().then( function(message) {
+                if (mode === 'clearsign'){
+                    resolve({
+                        data: message.data}
+                    );
+                } else if (mode === 'detached') {
+                    resolve({
+                        data: data,
+                        signature: message.data
+                    });
                 }
-                msg.post().then( function(message) {
-                    if (mode === 'clearsign'){
-                        resolve({
-                            data: message.data}
-                        );
-                    } else if (mode === 'detached') {
-                        resolve({
-                            data: data,
-                            signature: message.data
-                        });
-                    }
-                }, function(error){
-                    reject(error);
-                });
+            }, function(error){
+                reject(error);
             });
-        };
+        });
+    }
 
-        /**
-         * Verifies data.
-         * @param {String|Object} data text/data to be verified. Accepts Strings
-         * and Objects with a getText method
-         * @param {String} (optional) A detached signature. If not present,
-         * opaque mode is assumed
-         * @param {Boolean} (optional) Data and signature are base64 encoded
-         * @returns {Promise<verifyResult>}
-         *@async
-        */
-        this.verify= function (data, signature, base64 = false){
-            let msg = createMessage('verify');
-            let dt = putData(msg, data);
-            if (dt instanceof Error){
-                return Promise.reject(dt);
+    /**
+     * Verifies data.
+     * @param {String|Object} data text/data to be verified. Accepts Strings
+     * and Objects with a getText method
+     * @param {String} (optional) A detached signature. If not present,
+     * opaque mode is assumed
+     * @param {Boolean} (optional) Data and signature are base64 encoded
+     * @returns {Promise<verifyResult>}
+     *@async
+    */
+    verify (data, signature, base64 = false){
+        let msg = createMessage('verify');
+        let dt = putData(msg, data);
+        if (dt instanceof Error){
+            return Promise.reject(dt);
+        }
+        if (signature){
+            if (typeof(signature)!== 'string'){
+                return Promise.reject(gpgme_error('PARAM_WRONG'));
+            } else {
+                msg.setParameter('signature', signature);
             }
-            if (signature){
-                if (typeof(signature)!== 'string'){
-                    return Promise.reject(gpgme_error('PARAM_WRONG'));
+        }
+        if (base64 === true){
+            msg.setParameter('base64', true);
+        }
+        return new Promise(function(resolve, reject){
+            msg.post().then(function (message){
+                if (!message.info || !message.info.signatures){
+                    reject(gpgme_error('SIG_NO_SIGS'));
                 } else {
-                    msg.setParameter('signature', signature);
-                }
-            }
-            if (base64 === true){
-                msg.setParameter('base64', true);
-            }
-            return new Promise(function(resolve, reject){
-                msg.post().then(function (message){
-                    if (!message.info || !message.info.signatures){
-                        reject(gpgme_error('SIG_NO_SIGS'));
-                    } else {
-                        let _result = collectSignatures(
-                            message.info.signatures);
-                        _result.is_mime = message.info.is_mime? true: false;
-                        if (message.info.filename){
-                            _result.file_name = message.info.filename;
-                        }
-                        _result.data = message.data;
-                        resolve(_result);
+                    let _result = collectSignatures(
+                        message.info.signatures);
+                    _result.is_mime = message.info.is_mime? true: false;
+                    if (message.info.filename){
+                        _result.file_name = message.info.filename;
                     }
-                }, function(error){
-                    reject(error);
-                });
+                    _result.data = message.data;
+                    resolve(_result);
+                }
+            }, function(error){
+                reject(error);
             });
-        };
-    }
-
-    /**
-     * setter for {@link setKeyring}.
-     * @param {GPGME_Keyring} keyring A Keyring to use
-     */
-    set Keyring(keyring){
-        this.setKeyring(keyring);
-    }
-
-    /**
-     * Accesses the {@link GPGME_Keyring}.
-     */
-    get Keyring(){
-        return this.getKeyring();
+        });
     }
 }