The pyjamas-js from mattmaynes

The complexity of the decode function is 7. This is too damn high! The logic for upgrading can be abstracted to its own function which will reduce the complexity.

https://codeclimate.com/github/mattmaynes/pyjamas-js/src/pyjamas.js#all

Implement Viper.toJSON

/**
 * Returns a JSON string representation of a target instance
 *
 * @param target {object} Target object to serialized
 *
 * @return {string} JSON string representation of target
 *
 * @see Viper.manifest
 */
Viper.toJSON = function(){
    ...
};

Implement Pyjamas.Version.split

/**
 * Given a string representation of a version, convert the version
 * to a 3 element array
 *
 * @param version {string} A version identifier
 *
 * @return {Array<int>} [major, minor, patch] Version array
 */
function split (version){
    ...
}

Need to apply upgraders during construction

When an object is being constructed the upgraders need to be applied incrementally to the newly constructed object. This should probably done in a reduce operation

Fix "wrap-iife" issue in test/specs/unregister.spec.js

Move the invocation into the parens that contain the function.

https://codeclimate.com/github/mattmaynes/pyjamas-js/test/specs/unregister.spec.js#issue_56eeff6cab5ea70001093876

Overall test coverage over 95%

Fix "wrap-iife" issue in test/specs/manifest.spec.js

Move the invocation into the parens that contain the function.

https://codeclimate.com/github/mattmaynes/pyjamas-js/test/specs/manifest.spec.js#issue_56eeff6c81f26a00010bc0cf

Fix "wrap-iife" issue in test/specs/register.spec.js

Move the invocation into the parens that contain the function.

https://codeclimate.com/github/mattmaynes/pyjamas-js/test/specs/register.spec.js#issue_56eeff6cedb97100010a1e82

Add option to not call constructor on construct method

At times your constructor may require dependencies on other objects. Because of this if your constructor is called while these dependencies are not yet loaded, there will be issues. If an option could be made to attach the prototype and necessary attributes to the object without calling the constructor, this would be a good solution to this problem.

ie:

class MyClass {
    constructor() {
        this.test = Resource.getVal(1);
    }
}

This is a trivial example, but here we know that test is a defined value and we do not need to call the constructor to construct this object (in case Resource has not yet been defined)

Test Pyjamas.manifest

Implement Pyjamas.manifest

This should be a functional implementation that takes an object and returns a deep copy of the object with an added version tag. The return should be JSON persistable (i.e. no undefined members, no functions, etc.)

/**
 * Manifests an instance of a class as a bare-bones object that confirms
 * to JavaScript Object Notation. The resulting object will have no
 * undefined fields, functions or a constructor. There are no references
 * to the original constructor stored. It is up to the user to keep the
 * association of the return the type class definition of the manifested
 * object.
 *
 * @param target {object} Target object to manifest
 *
 * @return {object} Versioned persistable representation of target
 */
Pyjamas.manifest = function (){
    ...
};

Add support for alternate versioning systems

Pyjamas currently only supports major.minor.patch versions but there are many other versioning variations available. There should be a generic way to specify a version format

Implement Pyjamas.unregister

/**
 * Removes a class from the PyjamasDB if it exists, otherwise return null
 *
 * @param constructor {function} Object constructor to unregister
 *
 * @return {Pyjamas | null} Removed Pyjamas instance or null if the constructor
 * was not registered
 * @end
 */
Pyjamas.unregister = function (){
    ...
};

Add description of library to README

Add support for multiple parent inheritance

Currently Pyjamas supports extending a single registered Pyjamas instance to have one parent. We should be able to extend multiple parents into a signal child.

Pyjamas.register(MyClassA, '0.1.0', {
    a : String,
    b : Number,
    c : Object
}).extend(MyClassB).extend(MyClassC);

Here the parent of MyClassA will only be MyClassC. We want both MyClassB and MyClassC to be parents of MyClassA.

Implement Pyjamas.register

Should register a class as a version-able instance. Should return a "Pyjamas object" or something that allows you to add version upgraders.

/**
 * Registers a class into the PyjamasDB and returns a new Pajamas instance
 *
 * @example
 * Pyjamas.register(MyClass, '0.1.2', {
 *      foo : Number,
 *      bar : String,
 *      baz : MyOtherClass
 * });
 * @end
 *
 * @param constructor   {function}  Object constructor to register
 * @param version       {string}    Current version of object constructor
 * @param defines       {object}    Definitions of instance variables to
 * persist when given an instance of the constructor's class
 * @end
 *
 * @return {Pyjamas} A new viper instance
 */
Pyjamas.register = function (){};

Error thrown from nested registered attribute that is not in json

If you try to execute Pyjamas.construct(MyObject, json) where MyObject contains another registered object, and json does not contain a reference to that object, an error is thrown at line 463 when trying to index into the object.

ie:

Pyjamas.register(MyOtherObject, '0.0.1', { z: String });
Pyjamas.register(MyObject, '0.0.1', { x: MyOtherObject, y: String });

// This will cause an error, because it will try to index into 'x' (undefined) to get values
var ob2 = Pyjamas.construct(MyObject, { y: "test" });

Error: Cannot read property 'z' of undefined

Implement Pyjamas.construct

Should accept a class constructor and a raw object which we need to use to populate a new instance of the given class. If the class has any registered "version upgraders" then they should be applied to the new instance.

/**
 * Reconstructs a persisted object as an instance of the given constructor.
 * If the given target is not at the current version of the constructor then
 * upgraders will be successively applied until the highest version is
 * achieved.
 *
 * @param constructor   {function}  Object constructor
 * @param target        {object}    Raw instance to use to populate
 * a new instance of the constructor
 * @end
 *
 * @return {object} A new instance of the constructor
 */
Pyjamas.construct = function (){
    ...
};

/**
 * Returns the difference between two version numbers. This is a
 * pairwise comparison of each element in the version identifier.
 *
 * @param base  {string} Base version
 * @param other {string} Version to compare to
 *
 * @return {Array<int>} A pairwise comparison of each version number
 */
function diff (base, other){
    ...
}

Implement Pyjamas.prototype.upgrade

/**
 * Registers an upgrade function to this viper instance. An upgrade function
 * must accept a copy of a old version of a save and the current instance.
 * It should either mutate the current instance of the save or return an
 * upgraded version.
 *
 * @param version {string} Version code that indicates the version of the
 * instance returned from this upgrade function
 * @end
 *
 * @param upgrader {function} Function to upgrade old save. Prototype:
 * function( old :  Object, current : Object) : Object
 * @end
 *
 * @return {Pyjamas} An updated Viper instance
 */
Pyjamas.prototype.upgrade = function(){
    ...
};

Fix "wrap-iife" issue in test/specs/json.spec.js

Move the invocation into the parens that contain the function.

https://codeclimate.com/github/mattmaynes/pyjamas-js/test/specs/json.spec.js#issue_56eeff6c4a1a780001088f52

mattmaynes / pyjamas-js Goto Github PK

pyjamas-js's People

Contributors

Watchers

pyjamas-js's Issues

Recommend Projects

Recommend Topics

Recommend Org