1 /**

     2  * This file contains extensions for standard javascript types

     3  *

     4  */

     5 

     6 ONE_DAY = 86400000; // (in milliseconds)

     7 // ========== DATE EXTENSIONS ========== ///

     8 Date.prototype.equals = function(other) {

     9     /* compare with other date ignoring time differences */

    10     if (this.getYear() == other.getYear() && this.getMonth() == other.getMonth() && this.getDate() == other.getDate()) {

    11         return true;

    12     }

    13     return false;

    14 };

    15 

    16 Date.prototype.add = function(days) {

    17     var res = new Date();

    18     res.setTime(this.getTime() + (days * ONE_DAY));

    19     return res;

    20 };

    21 

    22 Date.prototype.sub = function(days) {

    23     return this.add( - days);

    24 };

    25 

    26 Date.prototype.iadd = function(days) {

    27     // in-place add

    28     this.setTime(this.getTime() + (days * ONE_DAY));

    29     // avoid strange rounding problems !!

    30     this.setHours(12);

    31 };

    32 

    33 Date.prototype.isub = function(days) {

    34     // in-place sub

    35     this.setTime(this.getTime() - (days * ONE_DAY));

    36 };

    37 

    38 /**

    39  * .. function:: Date.prototype.nextMonth()

    40  *

    41  * returns the first day of the next month

    42  */

    43 Date.prototype.nextMonth = function() {

    44     if (this.getMonth() == 11) {

    45         var d = new Date(this.getFullYear() + 1, 0, 1);

    46         return d;

    47     } else {

    48         var d2 = new Date(this.getFullYear(), this.getMonth() + 1, 1);

    49         return d2;

    50     }

    51 };

    52 

    53 /**

    54  * .. function:: Date.prototype.getRealDay()

    55  *

    56  * returns the day of week, 0 being monday, 6 being sunday

    57  */

    58 Date.prototype.getRealDay = function() {

    59     // getDay() returns 0 for Sunday ==> 6 for Saturday

    60     return (this.getDay() + 6) % 7;

    61 };

    62 

    63 Date.prototype.strftime = function(fmt) {

    64     if (this.toLocaleFormat !== undefined) { // browser dependent

    65         return this.toLocaleFormat(fmt);

    66     }

    67     // XXX implement at least a decent fallback implementation

    68     return this.getFullYear() + '/' + (this.getMonth() + 1) + '/' + this.getDate();

    69 };

    70 

    71 var _DATE_FORMAT_REGXES = {

    72     'Y': new RegExp('^-?[0-9]+'),

    73     'd': new RegExp('^[0-9]{1,2}'),

    74     'm': new RegExp('^[0-9]{1,2}'),

    75     'H': new RegExp('^[0-9]{1,2}'),

    76     'M': new RegExp('^[0-9]{1,2}')

    77 };

    78 

    79 /**

    80  * .. function:: _parseDate(datestring, format)

    81  *

    82  * _parseData does the actual parsing job needed by `strptime`

    83  */

    84 function _parseDate(datestring, format) {

    85     var skip0 = new RegExp('^0*[0-9]+');

    86     var parsed = {};

    87     for (var i1 = 0, i2 = 0; i1 < format.length; i1++, i2++) {

    88         var c1 = format.charAt(i1);

    89         var c2 = datestring.charAt(i2);

    90         if (c1 == '%') {

    91             c1 = format.charAt(++i1);

    92             var data = _DATE_FORMAT_REGXES[c1].exec(datestring.substring(i2));

    93             if (!data.length) {

    94                 return null;

    95             }

    96             data = data[0];

    97             i2 += data.length - 1;

    98             var value = parseInt(data, 10);

    99             if (isNaN(value)) {

   100                 return null;

   101             }

   102             parsed[c1] = value;

   103             continue;

   104         }

   105         if (c1 != c2) {

   106             return null;

   107         }

   108     }

   109     return parsed;

   110 }

   111 

   112 /**

   113  * .. function:: strptime(datestring, format)

   114  *

   115  * basic implementation of strptime. The only recognized formats

   116  * defined in _DATE_FORMAT_REGEXES (i.e. %Y, %d, %m, %H, %M)

   117  */

   118 function strptime(datestring, format) {

   119     var parsed = _parseDate(datestring, format);

   120     if (!parsed) {

   121         return null;

   122     }

   123     // create initial date (!!! year=0 means 1900 !!!)

   124     var date = new Date(0, 0, 1, 0, 0);

   125     date.setFullYear(0); // reset to year 0

   126     if (parsed.Y) {

   127         date.setFullYear(parsed.Y);

   128     }

   129     if (parsed.m) {

   130         if (parsed.m < 1 || parsed.m > 12) {

   131             return null;

   132         }

   133         // !!! month indexes start at 0 in javascript !!!

   134         date.setMonth(parsed.m - 1);

   135     }

   136     if (parsed.d) {

   137         if (parsed.m < 1 || parsed.m > 31) {

   138             return null;

   139         }

   140         date.setDate(parsed.d);

   141     }

   142     if (parsed.H) {

   143         if (parsed.H < 0 || parsed.H > 23) {

   144             return null;

   145         }

   146         date.setHours(parsed.H);

   147     }

   148     if (parsed.M) {

   149         if (parsed.M < 0 || parsed.M > 59) {

   150             return null;

   151         }

   152         date.setMinutes(parsed.M);

   153     }

   154     return date;

   155 }

   156 

   157 // ========== END OF DATE EXTENSIONS ========== ///

   158 // ========== STRING EXTENSIONS ========== //

   159 /**

   160  * .. function:: String.prototype.startswith(prefix)

   161  *

   162  * python-like startsWith method for js strings

   163  * >>>

   164  */

   165 String.prototype.startswith = function(prefix) {

   166     return this.indexOf(prefix) == 0;

   167 };

   168 

   169 /**

   170  * .. function:: String.prototype.endswith(suffix)

   171  *

   172  * python-like endsWith method for js strings

   173  */

   174 String.prototype.endswith = function(suffix) {

   175     var startPos = this.length - suffix.length;

   176     if (startPos < 0) {

   177         return false;

   178     }

   179     return this.lastIndexOf(suffix, startPos) == startPos;

   180 };

   181 

   182 /**

   183  * .. function:: String.prototype.strip()

   184  *

   185  * python-like strip method for js strings

   186  */

   187 String.prototype.strip = function() {

   188     return this.replace(/^\s*(.*?)\s*$/, "$1");

   189 };

   190 

   191 /**

   192  * .. function:: String.prototype.rstrip()

   193  *

   194  * python-like rstrip method for js strings

   195  */

   196 String.prototype.rstrip = function(str) {

   197     if (!str) { str = '\s' ; }

   198     return this.replace(new RegExp('^(.*?)' + str + '*$'), "$1");

   199 };

   200 

   201 // ========= class factories ========= //

   202 

   203 /**

   204  * .. function:: makeUnboundMethod(meth)

   205  *

   206  * transforms a function into an unbound method

   207  */

   208 function makeUnboundMethod(meth) {

   209     function unboundMeth(self) {

   210         var newargs = cw.utils.sliceList(arguments, 1);

   211         return meth.apply(self, newargs);

   212     }

   213     unboundMeth.__name__ = meth.__name__;

   214     return unboundMeth;

   215 }

   216 

   217 function attachMethodToClass(cls, methname, meth) {

   218     meth.__name__ = methname;

   219     // XXX : this is probably bad for memory usage

   220     cls.__dict__[methname] = meth;

   221     cls[methname] = makeUnboundMethod(meth); // for the class itself

   222     cls.prototype[methname] = meth; // for the instance

   223 }

   224 

   225 /**

   226  * .. function:: _isAttrSkipped(attrname)

   227  *

   228  * simple internal function that tells if the attribute should

   229  * be copied from baseclasses or not

   230  */

   231 function _isAttrSkipped(attrname) {

   232     var skipped = ['__class__', '__dict__', '__bases__', 'prototype'];

   233     for (var i = 0; i < skipped.length; i++) {

   234         if (skipped[i] == attrname) {

   235             return true;

   236         }

   237     }

   238     return false;

   239 }

   240 

   241 /**

   242  * .. function:: makeConstructor(userctor)

   243  *

   244  * internal function used to build the class constructor

   245  */

   246 function makeConstructor(userctor) {

   247     return function() {

   248         // this is a proxy to user's __init__

   249         if (userctor) {

   250             userctor.apply(this, arguments);

   251         }

   252     };

   253 }

   254 

   255 /**

   256  * .. function:: defclass(name, bases, classdict)

   257  *

   258  * this is a js class factory. objects returned by this function behave

   259  * more or less like a python class. The `class` function prototype is

   260  * inspired by the python `type` builtin

   261  *

   262  * .. Note::

   263  *

   264  *    * methods are _STATICALLY_ attached when the class it created

   265  *    * multiple inheritance was never tested, which means it doesn't work ;-)

   266  */

   267 function defclass(name, bases, classdict) {

   268     var baseclasses = bases || [];

   269 

   270     // this is the static inheritance approach (<=> differs from python)

   271     var basemeths = {};

   272     var reverseLookup = [];

   273     for (var i = baseclasses.length - 1; i >= 0; i--) {

   274         reverseLookup.push(baseclasses[i]);

   275     }

   276     reverseLookup.push({

   277         '__dict__': classdict

   278     });

   279 

   280     for (var i = 0; i < reverseLookup.length; i++) {

   281         var cls = reverseLookup[i];

   282         for (prop in cls.__dict__) {

   283             // XXX hack to avoid __init__, __bases__...

   284             if (!_isAttrSkipped(prop)) {

   285                 basemeths[prop] = cls.__dict__[prop];

   286             }

   287         }

   288     }

   289     var userctor = basemeths['__init__'];

   290     var constructor = makeConstructor(userctor);

   291 

   292     // python-like interface

   293     constructor.__name__ = name;

   294     constructor.__bases__ = baseclasses;

   295     constructor.__dict__ = {};

   296     constructor.prototype.__class__ = constructor;

   297     // make bound / unbound methods

   298     for (methname in basemeths) {

   299         attachMethodToClass(constructor, methname, basemeths[methname]);

   300     }

   301 

   302     return constructor;

   303 }