JavaStrict

Strict Type JavaScript

Fast, simple and Enterprise Ready way to add arguments and / or return value type on one or more function, callback or method.

Inspired on ActionScript 2.0 Strict Type behaviour.

Why JavaStrict ?

Every runtime compiled/executed program language requires hard debug instead of hard code and sometime we spend too much time, using big libraries, to find wrong objects, variables or methods during code execution.

We have a lot of cool debuggers to add breakpoints, print on console each step but any automated check about each used function, its arguments and its expected return value type.

JavaStrict tiny library allows developers to use a sort of Strict Type declaration for one or more function or method, respecting scope, isntances types and return type if it’s not Void (undefined).

With a minimun performance impact that should be easyly removed declaring public Strict.debug value to false, every JavaScript developer could write strongly typed constructors or global functions, knowing every time when and where recieved arguments are not exactly expected one.

JavaStrict is Enterprise Ready because code design need to be less scriptish and more strictly and at the same time it adds automatically informations about each method or function, showing return type and arguments type forcing users to respect them even removing documentation.

Version

Browser Compatibility

Every browser compatible with:

• Function apply or call method
• try{ ...  } catch(e){ ...  }
• instanceof

Author

Andrea Giammarchi, http://www.3site.eu

License

Copyright (C) 2007 Andrea Giammarchi - www.3site.eu

Permission is hereby granted, free of charge,
to any person obtaining a copy of this software and associated
documentation files (the "Software"),
to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Source Code

// (C) Andrea Giammarchi [www.3site.eu] - MIT Style License
function Strict(returnValue, callback, arguments, name){
       return  Strict.debug ? Strict.returnValue(returnValue, Strict.apply(callback, arguments, name), name) : callback
};
Strict.apply = function(callback, args, name){
       return  Strict.debug ? function(){
               for(var i = 0; i < arguments.length ; i++){
                       if(!Strict.check(arguments[i], args[i]))
                               throw new Error("[".concat(name || callback.name, "] Strict arguments ", i, " Error"));
               };
               return callback.apply(this, arguments)
       } : callback
};
Strict.call = function(){
       var     name = (arguments = [].slice.call(arguments)).length,
               callback = arguments.shift();
       return  Strict.debug ? Strict.apply(callback, arguments, Strict.check(arguments[name-2], "".constructor) ? arguments.pop() : Strict.Void) : callback
};
Strict.check = function(arguments, constructor){
       var     returnValue = constructor === Strict.Void;
       return  arguments === Strict.Void ? returnValue : (arguments === null ? !returnValue : (returnValue ? false : (Strict.object ? (typeof arguments === "object" ? arguments instanceof constructor : arguments.constructor === constructor) : (constructor === Object ? true : (arguments instanceof constructor || arguments.constructor === constructor)))))
};
Strict.returnValue = function(args, callback, name){
       return  Strict.debug ? function(){
               var     returnValue = callback.apply(this, arguments);
               if(!Strict.check(returnValue, args))
                       throw new Error("[".concat(name || callback.name, "] Strict returnValue Error"));
               return returnValue
       } : callback
};
Strict.debug = true;                   // set false on production enviroment to increase performances removing Strict checks
Strict.object = false;                 // set true to check primitives too
var    Void = Strict.Void = Strict.Void;