docs/source/Version.html

   1 <!DOCTYPE html>
   2 <html>
   3 <head>
   4   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   5   <title>The source code</title>
   6   <link href="../prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../prettify/prettify.js"></script>
   8   <style type="text/css">
   9     .highlight { display: block; background-color: #ddd; }
  10   </style>
  11   <script type="text/javascript">
  12     function highlight() {
  13       document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
  14     }
  15   </script>
  16 </head>
  17 <body onload="prettyPrint(); highlight();">
  18   <pre class="prettyprint lang-js"><span id='Ext-Version'>/**
  19 </span> * @author Jacky Nguyen &lt;jacky@sencha.com&gt;
  20  * @docauthor Jacky Nguyen &lt;jacky@sencha.com&gt;
  21  * @class Ext.Version
  22  *
  23  * A utility class that wrap around a string version number and provide convenient
  24  * method to perform comparison. See also: {@link Ext.Version#compare compare}. Example:
  25
  26     var version = new Ext.Version('1.0.2beta');
  27     console.log(&quot;Version is &quot; + version); // Version is 1.0.2beta
  28
  29     console.log(version.getMajor()); // 1
  30     console.log(version.getMinor()); // 0
  31     console.log(version.getPatch()); // 2
  32     console.log(version.getBuild()); // 0
  33     console.log(version.getRelease()); // beta
  34
  35     console.log(version.isGreaterThan('1.0.1')); // True
  36     console.log(version.isGreaterThan('1.0.2alpha')); // True
  37     console.log(version.isGreaterThan('1.0.2RC')); // False
  38     console.log(version.isGreaterThan('1.0.2')); // False
  39     console.log(version.isLessThan('1.0.2')); // True
  40
  41     console.log(version.match(1.0)); // True
  42     console.log(version.match('1.0.2')); // True
  43
  44  * @markdown
  45  */
  46 (function() {
  47
  48 // Current core version
  49 var version = '4.0.0', Version;
  50     Ext.Version = Version = Ext.extend(Object, {
  51
  52 <span id='Ext-Version-method-constructor'>        /**
  53 </span>         * @constructor
  54          * @param {String/Number} version The version number in the follow standard format: major[.minor[.patch[.build[release]]]]
  55          * Examples: 1.0 or 1.2.3beta or 1.2.3.4RC
  56          * @return {Ext.Version} this
  57          * @param version
  58          */
  59         constructor: function(version) {
  60             var parts, releaseStartIndex;
  61
  62             if (version instanceof Version) {
  63                 return version;
  64             }
  65
  66             this.version = this.shortVersion = String(version).toLowerCase().replace(/_/g, '.').replace(/[\-+]/g, '');
  67
  68             releaseStartIndex = this.version.search(/([^\d\.])/);
  69
  70             if (releaseStartIndex !== -1) {
  71                 this.release = this.version.substr(releaseStartIndex, version.length);
  72                 this.shortVersion = this.version.substr(0, releaseStartIndex);
  73             }
  74
  75             this.shortVersion = this.shortVersion.replace(/[^\d]/g, '');
  76
  77             parts = this.version.split('.');
  78
  79             this.major = parseInt(parts.shift() || 0, 10);
  80             this.minor = parseInt(parts.shift() || 0, 10);
  81             this.patch = parseInt(parts.shift() || 0, 10);
  82             this.build = parseInt(parts.shift() || 0, 10);
  83
  84             return this;
  85         },
  86
  87 <span id='Ext-Version-method-toString'>        /**
  88 </span>         * Override the native toString method
  89          * @private
  90          * @return {String} version
  91          */
  92         toString: function() {
  93             return this.version;
  94         },
  95
  96 <span id='Ext-Version-method-valueOf'>        /**
  97 </span>         * Override the native valueOf method
  98          * @private
  99          * @return {String} version
 100          */
 101         valueOf: function() {
 102             return this.version;
 103         },
 104
 105 <span id='Ext-Version-method-getMajor'>        /**
 106 </span>         * Returns the major component value
 107          * @return {Number} major
 108          */
 109         getMajor: function() {
 110             return this.major || 0;
 111         },
 112
 113 <span id='Ext-Version-method-getMinor'>        /**
 114 </span>         * Returns the minor component value
 115          * @return {Number} minor
 116          */
 117         getMinor: function() {
 118             return this.minor || 0;
 119         },
 120
 121 <span id='Ext-Version-method-getPatch'>        /**
 122 </span>         * Returns the patch component value
 123          * @return {Number} patch
 124          */
 125         getPatch: function() {
 126             return this.patch || 0;
 127         },
 128
 129 <span id='Ext-Version-method-getBuild'>        /**
 130 </span>         * Returns the build component value
 131          * @return {Number} build
 132          */
 133         getBuild: function() {
 134             return this.build || 0;
 135         },
 136
 137 <span id='Ext-Version-method-getRelease'>        /**
 138 </span>         * Returns the release component value
 139          * @return {Number} release
 140          */
 141         getRelease: function() {
 142             return this.release || '';
 143         },
 144
 145 <span id='Ext-Version-method-isGreaterThan'>        /**
 146 </span>         * Returns whether this version if greater than the supplied argument
 147          * @param {String/Number} target The version to compare with
 148          * @return {Boolean} True if this version if greater than the target, false otherwise
 149          */
 150         isGreaterThan: function(target) {
 151             return Version.compare(this.version, target) === 1;
 152         },
 153
 154 <span id='Ext-Version-method-isLessThan'>        /**
 155 </span>         * Returns whether this version if smaller than the supplied argument
 156          * @param {String/Number} target The version to compare with
 157          * @return {Boolean} True if this version if smaller than the target, false otherwise
 158          */
 159         isLessThan: function(target) {
 160             return Version.compare(this.version, target) === -1;
 161         },
 162
 163 <span id='Ext-Version-method-equals'>        /**
 164 </span>         * Returns whether this version equals to the supplied argument
 165          * @param {String/Number} target The version to compare with
 166          * @return {Boolean} True if this version equals to the target, false otherwise
 167          */
 168         equals: function(target) {
 169             return Version.compare(this.version, target) === 0;
 170         },
 171
 172 <span id='Ext-Version-method-match'>        /**
 173 </span>         * Returns whether this version matches the supplied argument. Example:
 174          * &lt;pre&gt;&lt;code&gt;
 175          * var version = new Ext.Version('1.0.2beta');
 176          * console.log(version.match(1)); // True
 177          * console.log(version.match(1.0)); // True
 178          * console.log(version.match('1.0.2')); // True
 179          * console.log(version.match('1.0.2RC')); // False
 180          * &lt;/code&gt;&lt;/pre&gt;
 181          * @param {String/Number} target The version to compare with
 182          * @return {Boolean} True if this version matches the target, false otherwise
 183          */
 184         match: function(target) {
 185             target = String(target);
 186             return this.version.substr(0, target.length) === target;
 187         },
 188
 189 <span id='Ext-Version-method-toArray'>        /**
 190 </span>         * Returns this format: [major, minor, patch, build, release]. Useful for comparison
 191          * @return {Array}
 192          */
 193         toArray: function() {
 194             return [this.getMajor(), this.getMinor(), this.getPatch(), this.getBuild(), this.getRelease()];
 195         },
 196
 197 <span id='Ext-Version-method-getShortVersion'>        /**
 198 </span>         * Returns shortVersion version without dots and release
 199          * @return {String}
 200          */
 201         getShortVersion: function() {
 202             return this.shortVersion;
 203         }
 204     });
 205
 206     Ext.apply(Version, {
 207         // @private
 208         releaseValueMap: {
 209             'dev': -6,
 210             'alpha': -5,
 211             'a': -5,
 212             'beta': -4,
 213             'b': -4,
 214             'rc': -3,
 215             '#': -2,
 216             'p': -1,
 217             'pl': -1
 218         },
 219
 220 <span id='Ext-Version-method-getComponentValue'>        /**
 221 </span>         * Converts a version component to a comparable value
 222          *
 223          * @static
 224          * @param {Mixed} value The value to convert
 225          * @return {Mixed}
 226          */
 227         getComponentValue: function(value) {
 228             return !value ? 0 : (isNaN(value) ? this.releaseValueMap[value] || value : parseInt(value, 10));
 229         },
 230
 231 <span id='Ext-Version-method-compare'>        /**
 232 </span>         * Compare 2 specified versions, starting from left to right. If a part contains special version strings,
 233          * they are handled in the following order:
 234          * 'dev' &lt; 'alpha' = 'a' &lt; 'beta' = 'b' &lt; 'RC' = 'rc' &lt; '#' &lt; 'pl' = 'p' &lt; 'anything else'
 235          *
 236          * @static
 237          * @param {String} current The current version to compare to
 238          * @param {String} target The target version to compare to
 239          * @return {Number} Returns -1 if the current version is smaller than the target version, 1 if greater, and 0 if they're equivalent
 240          */
 241         compare: function(current, target) {
 242             var currentValue, targetValue, i;
 243
 244             current = new Version(current).toArray();
 245             target = new Version(target).toArray();
 246
 247             for (i = 0; i &lt; Math.max(current.length, target.length); i++) {
 248                 currentValue = this.getComponentValue(current[i]);
 249                 targetValue = this.getComponentValue(target[i]);
 250
 251                 if (currentValue &lt; targetValue) {
 252                     return -1;
 253                 } else if (currentValue &gt; targetValue) {
 254                     return 1;
 255                 }
 256             }
 257
 258             return 0;
 259         }
 260     });
 261
 262     Ext.apply(Ext, {
 263 <span id='Ext-Version-property-versions'>        /**
 264 </span>         * @private
 265          */
 266         versions: {},
 267
 268 <span id='Ext-Version-property-lastRegisteredVersion'>        /**
 269 </span>         * @private
 270          */
 271         lastRegisteredVersion: null,
 272
 273 <span id='Ext-Version-method-setVersion'>        /**
 274 </span>         * Set version number for the given package name.
 275          *
 276          * @param {String} packageName The package name, for example: 'core', 'touch', 'extjs'
 277          * @param {String/Ext.Version} version The version, for example: '1.2.3alpha', '2.4.0-dev'
 278          * @return {Ext}
 279          */
 280         setVersion: function(packageName, version) {
 281             Ext.versions[packageName] = new Version(version);
 282             Ext.lastRegisteredVersion = Ext.versions[packageName];
 283
 284             return this;
 285         },
 286
 287 <span id='Ext-Version-method-getVersion'>        /**
 288 </span>         * Get the version number of the supplied package name; will return the last registered version
 289          * (last Ext.setVersion call) if there's no package name given.
 290          *
 291          * @param {String} packageName (Optional) The package name, for example: 'core', 'touch', 'extjs'
 292          * @return {Ext.Version} The version
 293          */
 294         getVersion: function(packageName) {
 295             if (packageName === undefined) {
 296                 return Ext.lastRegisteredVersion;
 297             }
 298
 299             return Ext.versions[packageName];
 300         },
 301
 302 <span id='Ext-Version-method-deprecate'>        /**
 303 </span>         * Create a closure for deprecated code.
 304          *
 305     // This means Ext.oldMethod is only supported in 4.0.0beta and older.
 306     // If Ext.getVersion('extjs') returns a version that is later than '4.0.0beta', for example '4.0.0RC',
 307     // the closure will not be invoked
 308     Ext.deprecate('extjs', '4.0.0beta', function() {
 309         Ext.oldMethod = Ext.newMethod;
 310
 311         ...
 312     });
 313
 314          * @param {String} packageName The package name
 315          * @param {String} since The last version before it's deprecated
 316          * @param {Function} closure The callback function to be executed with the specified version is less than the current version
 317          * @param {Object} scope The execution scope (&lt;tt&gt;this&lt;/tt&gt;) if the closure
 318          * @markdown
 319          */
 320         deprecate: function(packageName, since, closure, scope) {
 321             if (Version.compare(Ext.getVersion(packageName), since) &lt; 1) {
 322                 closure.call(scope);
 323             }
 324         }
 325     }); // End Versioning
 326
 327     Ext.setVersion('core', version);
 328
 329 })();
 330 </pre>
 331 </body>
 332 </html>