docs/source/Version.html

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