├── .gitignore
├── .jshintrc
├── .travis.yml
├── Jakefile
├── README.md
├── benchmarks
    └── benchmark.js
├── bower.json
├── package.json
├── spec
    ├── date.spec.js
    ├── test-utils.js
    ├── tz.async.spec.js
    ├── tz.default.spec.js
    ├── tz.manual.spec.js
    ├── tz.preload.spec.js
    └── tz.sync.spec.js
└── src
    ├── date.js
    ├── node-preparse.js
    ├── preparse.js
    └── strip_olson_comments.rb


/.gitignore:
--------------------------------------------------------------------------------
 1 | .DS*
 2 | tests/tz
 3 | tests/jasmine
 4 | lib
 5 | node_modules
 6 | docs
 7 | .c9*
 8 | .settings
 9 | *.local.spec.js
10 | 


--------------------------------------------------------------------------------
/.jshintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "laxcomma": true,
 3 |   "browser": true,
 4 |   "globalstrict": true,
 5 |   "strict": true,
 6 |   "expr": true,
 7 |   "multistr": true,
 8 |   "globals": {
 9 |     "define": true,
10 |     "window": true,
11 |     "module": true,
12 |     "exports": true
13 |   }
14 | }


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: node_js
 2 | node_js:
 3 |   - "0.10"
 4 |   - "0.8"
 5 | 
 6 | notifications:
 7 |   email:
 8 |     recipients:
 9 |       - mde@fleegix.org
10 |       - holevietlong@gmail.com
11 | 
12 | 


--------------------------------------------------------------------------------
/Jakefile:
--------------------------------------------------------------------------------
 1 | var fs = require('fs')
 2 |   , path = require('path');
 3 | 
 4 | namespace('test', function () {
 5 | 
 6 |   desc('Sets up tests by downloading the timezone data.');
 7 |   task('init', ['updateTzData'], function () {
 8 |     complete();
 9 |   }, {async: true});
10 | 
11 |   task('clobberTzData', function () {
12 |     console.log('Removing old timezone data.');
13 |     jake.rmRf('lib/tz');
14 |   });
15 | 
16 |   desc('Downloads the newest timezone data.');
17 |   task('updateTzData', ['clobberTzData'], function () {
18 |     var cmds = [
19 |       'echo "Downloading new timezone data ..."'
20 |     , 'curl ftp://ftp.iana.org/tz/tzdata-latest.tar.gz ' +
21 |           '-o lib/tz/tzdata-latest.tar.gz'
22 |     , 'echo "Expanding archive ..."'
23 |     , 'tar -xvzf lib/tz/tzdata-latest.tar.gz -C lib/tz'
24 |     ];
25 |     jake.mkdirP('lib/tz');
26 |     jake.exec(cmds, function () {
27 |       console.log('Retrieved new timezone data');
28 |       console.log('Parsing tz...');
29 |       jake.exec('node src/node-preparse.js lib/tz > lib/all_cities.json', function () {
30 |         console.log('Done parsing tz');
31 |         complete();
32 |       }, {printStdout: true, printStderr: true});
33 |     }, {printStdout: true});
34 |   }, {async: true});
35 | 
36 |   task('run', function () {
37 |     //Comply to 0.8.0 and 0.6.x
38 |     var existsSync = fs.existsSync || path.existsSync;
39 |     if (!existsSync('lib/tz')) {
40 |       fail('No timezone data. Please run "jake test:init".');
41 |     }
42 |     jake.exec(['./node_modules/jasmine-node/bin/jasmine-node spec'], function () {
43 |       complete();
44 |     }, {printStdout: true});
45 | 
46 |   }, {async: true});
47 | 
48 |   task('cli', ['init', 'run']);
49 | 
50 | });
51 | 
52 | desc('Runs the tests.');
53 | task('test', ['test:run'], function () {});
54 | 
55 | namespace('doc', function () {
56 |   task('generate', ['doc:clobber'], function () {
57 |     var cmd = 'docco src/date.js';
58 |     console.log('Generating docs ...');
59 |     jake.exec([cmd], function () {
60 |       console.log('Done.');
61 |       complete();
62 |     });
63 |   }, {async: true});
64 | 
65 |   task('clobber', function () {
66 |     var cmd = 'rm -fr ./docs';
67 |     jake.exec([cmd], function () {
68 |       console.log('Clobbered old docs.');
69 |       complete();
70 |     });
71 |   }, {async: true});
72 | 
73 | });
74 | 
75 | desc('Generates docs.');
76 | task('doc', ['doc:generate']);
77 | 
78 | publishTask('timezone-js',
79 |     {versionFiles: ['package.json', 'bower.json']} , function () {
80 |   this.packageFiles.include([
81 |     'Jakefile'
82 |   , 'README.md'
83 |   , 'package.json'
84 |   , 'spec/*'
85 |   , 'src/*'
86 |   ]);
87 | });
88 | 
89 | jake.Task['publish:updateVersionFiles'].on('complete', function (version) {
90 |   var code = fs.readFileSync('./src/date.js').toString();
91 |   code = code.replace(/timezoneJS.VERSION = '.+'/m,
92 |       "timezoneJS.VERSION = '" + version  + "'");
93 |   fs.writeFileSync('./src/date.js', code);
94 | });
95 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # TimezoneJS.Date
  2 | 
  3 | [![Build Status](https://secure.travis-ci.org/mde/timezone-js.png)](https://secure.travis-ci.org/mde/timezone-js)
  4 | 
  5 | A timezone-enabled, drop-in replacement for the stock JavaScript Date. The `timezoneJS.Date` object is API-compatible with JS Date, with the same getter and setter methods -- it should work fine in any code that works with normal JavaScript Dates.
  6 | 
  7 | [Mailing list](http://groups.google.com/group/timezone-js)
  8 | 
  9 | ## Overview
 10 | 
 11 | The `timezoneJS.Date` object gives you full-blown timezone support, independent from the timezone set on the end-user's machine running the browser. It uses the Olson zoneinfo files for its timezone data.
 12 | 
 13 | The constructor function and setter methods use proxy JavaScript Date objects behind the scenes, so you can use strings like '10/22/2006' with the constructor. You also get the same sensible wraparound behavior with numeric parameters (like setting a value of 14 for the month wraps around to the next March).
 14 | 
 15 | The other significant difference from the built-in JavaScript Date is that `timezoneJS.Date` also has named properties that store the values of year, month, date, etc., so it can be directly serialized to JSON and used for data transfer.
 16 | 
 17 | ## Setup
 18 | 
 19 | This section shows the most common way of setting up timezone-js. In the 'Customizing' section below you can find alternative approaches.
 20 | 
 21 | First you'll need to include the code on your page. Both `timezoneJS.Date`, and the supporting code it needs in `timezoneJS.timezone` are bundled in the `date.js` file in `src` directory. Include the code on your page with a normal JavaScript script include, like so:
 22 | 
 23 | 	<script type="text/javascript" src="/js/timezone-js/src/date.js">
 24 | 
 25 | Next you'll need the Olson time zone files -- `timezoneJS.Date` uses the raw Olson data to calculate timezone offsets. The Olson region files are simple, structured text data, which download quickly and parse easily. (They also compress to a very small size.)
 26 | 
 27 | Here is an example of how to get the Olson time zone files:
 28 | 
 29 | ``` bash
 30 | ##!/bin/bash
 31 | 
 32 | # NOTE: Run from your webroot
 33 | 
 34 | # Create the /tz directory
 35 | mkdir tz
 36 | 
 37 | # Download the latest Olson files
 38 | curl ftp://ftp.iana.org/tz/tzdata-latest.tar.gz -o tz/tzdata-latest.tar.gz
 39 | 
 40 | # Expand the files
 41 | tar -xvzf tz/tzdata-latest.tar.gz -C tz
 42 | 
 43 | # Optionally, you can remove the downloaded archives.
 44 | rm tz/tzdata-latest.tar.gz
 45 | ```
 46 | 
 47 | Then you'll need to make the files available to the `timezoneJS.timezone` code, and initialize the code to parse your default region. (This will be North America if you don't change it). No sense in downloading and parsing timezone data for the entire world if you're not going to be using it.
 48 | 
 49 | Put your directory of Olson files somewhere under your Web server root, and point `timezoneJS.timezone.zoneFileBasePath` to it. Then call the init function. Your code will look something like this:
 50 | 
 51 | ``` js
 52 | timezoneJS.timezone.zoneFileBasePath = '/tz';
 53 | timezoneJS.timezone.init({ callback: cb });
 54 | ```
 55 | 
 56 | If you use `timezoneJS.Date` with `Fleegix.js`, `jQuery` or `jQuery`-compatible libraries (like `Zepto.js`), there's nothing else you need to do -- timezones for North America will be loaded and parsed on initial page load, and others will be downloaded and parsed on-the-fly, as needed. If you want to use this code with some other JavaScript toolkit, you'll need to overwrite your own transport method by setting `timezoneJS.timezone.transport = someFunction` method. Take a look at `test-utils.js` in `spec` for an example.
 57 | 
 58 | **NOTE**: By default `init()` is async so you'll need to specify a callback function such as `init({ callback: cb })`. Otherwise set `init({ async: false })` to turn off async.
 59 | 
 60 | ## Usage
 61 | 
 62 | The `timezoneJS.Date` constructor is compatible to the normal JavaScript Date constructor, but additional allows to pass an optional `tz` (timezone). In the following cases the passed date/time is unambiguous:
 63 | 
 64 | ``` js
 65 | timezoneJS.Date(millis, [tz])
 66 | timezoneJS.Date(Date, [tz])
 67 | timezoneJS.Date(dt_str_tz, [tz])
 68 | ```
 69 | 
 70 | `dt_str_tz` is a date string containing timezone information, i.e. containing `Z`, `T` or a timezone offset matching the regular expression `/[+-][0-9]{4}/` (e.g. `+0200`). The [one-stop shop for cross-browser JavaScript Date parsing behavior](http://dygraphs.com/date-formats.html) provides detailed information about JavaScript date formats.
 71 | 
 72 | In the following cases the date is assumed to be a date in timezone `tz` or a locale date if `tz` is not provided:
 73 | 
 74 | ``` js
 75 | timezoneJS.Date(year, mon, day, [hour], [min], [second], [tz])
 76 | timezoneJS.Date(dt_str, [tz])
 77 | ```
 78 | 
 79 | `dt_str` is a date string containing no timezone information.
 80 | 
 81 | ### Examples
 82 | 
 83 | Create a `timezoneJS.Date` the same way as a normal JavaScript Date, but append a timezone parameter on the end:
 84 | 
 85 | ``` js
 86 | var dt = new timezoneJS.Date('10/31/2008', 'America/New_York');
 87 | var dt = new timezoneJS.Date(2008, 9, 31, 11, 45, 'America/Los_Angeles');
 88 | ```
 89 | 
 90 | Naturally enough, the `getTimezoneOffset` method returns the timezone offset in minutes based on the timezone you set for the date.
 91 | 
 92 | ``` js
 93 | // Pre-DST-leap
 94 | var dt = new timezoneJS.Date(2006, 9, 29, 1, 59, 'America/Los_Angeles');
 95 | dt.getTimezoneOffset(); => 420
 96 | // Post-DST-leap
 97 | var dt = new timezoneJS.Date(2006, 9, 29, 2, 0, 'America/Los_Angeles');
 98 | dt.getTimezoneOffset(); => 480
 99 | ```
100 | 
101 | Just as you'd expect, the `getTime` method gives you the UTC timestamp for the given date:
102 | 
103 | ``` js
104 | var dtA = new timezoneJS.Date(2007, 9, 31, 10, 30, 'America/Los_Angeles');
105 | var dtB = new timezoneJS.Date(2007, 9, 31, 12, 30, 'America/Chicago');
106 | // Same timestamp
107 | dtA.getTime(); => 1193855400000
108 | dtB.getTime(); => 1193855400000
109 | ```
110 | 
111 | You can set (or reset) the timezone using the `setTimezone` method:
112 | 
113 | ``` js
114 | var dt = new timezoneJS.Date('10/31/2006', 'America/Juneau');
115 | dt.getTimezoneOffset(); => 540
116 | dt.setTimezone('America/Chicago');
117 | dt.getTimezoneOffset(); => 300
118 | dt.setTimezone('Pacific/Honolulu');
119 | dt.getTimezoneOffset(); => 600
120 | ```
121 | 
122 | The `getTimezone` method tells you what timezone a `timezoneJS.Date` is set to:
123 | 
124 | ``` js
125 | var dt = new timezoneJS.Date('12/27/2010', 'Asia/Tokyo');
126 | dt.getTimezone(); => 'Asia/Tokyo'
127 | ```
128 | 
129 | You can use `getTimezoneAbbreviation` method to get timezone abbreviation:
130 | 
131 | ``` js
132 | var dt = new timezoneJS.Date('10/31/2008', 'America/New_York');
133 | dt.getTimezoneAbbreviation(); => 'EDT'
134 | ```
135 | 
136 | ## Customizing
137 | 
138 | If you don't change it, the timezone region that loads on
139 |  initialization is North America (the Olson 'northamerica' file). To change that to another reqion, set `timezoneJS.timezone.defaultZoneFile` to your desired region, like so:
140 |  ``` js
141 | timezoneJS.timezone.zoneFileBasePath = '/tz';
142 | timezoneJS.timezone.defaultZoneFile = 'asia';
143 | timezoneJS.timezone.init();
144 | ```
145 | 
146 | If you want to preload multiple regions, set it to an array, like this:
147 | 
148 | ``` js
149 | timezoneJS.timezone.zoneFileBasePath = '/tz';
150 | timezoneJS.timezone.defaultZoneFile = ['asia', 'backward', 'northamerica', 'southamerica'];
151 | timezoneJS.timezone.init();
152 | ```
153 | 
154 | By default the `timezoneJS.Date` timezone code lazy-loads the timezone data files, pulling them down and parsing them only as needed.
155 | 
156 | For example, if you go with the out-of-the-box setup, you'll have all the North American timezones pre-loaded -- but if you were to add a date with a timezone of 'Asia/Seoul,' it would grab the 'asia' Olson file and parse it before calculating the timezone offset for that date.
157 | 
158 | You can change this behavior by changing the value of `timezoneJS.timezone.loadingScheme`. The three possible values are:
159 | 
160 | 1. `timezoneJS.timezone.loadingSchemes.PRELOAD_ALL` -- this will preload all the timezone data files for all reqions up front. This setting would only make sense if you know your users will be using timezones from all around the world, and you prefer taking the up-front load time to the small on-the-fly lag from lazy loading.
161 | 2. `timezoneJS.timezone.loadingSchemes.LAZY_LOAD` -- the default. Loads some amount of data up front, then lazy-loads any other needed timezone data as needed.
162 | 3. `timezoneJS.timezone.loadingSchemes.MANUAL_LOAD` -- Preloads no data, and does no lazy loading. Use this setting if you're loading pre-parsed JSON timezone data.
163 | 
164 | ## Ready-made tzdata NPM modules
165 | 
166 | If you use NPM, and you want to load the time zone data synchronously, you can use one or more of the tzdata* NPM modules. That way, you do not have to download the IANA zone files manually, you can just run `npm update` to get the latest data.
167 | 
168 | The [tzdata](https://www.npmjs.com/package/tzdata) module contains all time zones. There are other modules, e.g. [tzdata-northamerica](https://www.npmjs.com/package/tzdata-northamerica) that contain subsets of the zones.
169 | 
170 | First, install timezone-js and one or more of the tzdata modules.
171 | ```bash
172 | npm install timezone-js tzdata
173 | ```
174 | 
175 | Then, initialize timezone-js with the data:
176 | ```javascript
177 | var timezoneJS = require("timezone-js");
178 | var tzdata = require("tzdata");
179 | 
180 | var _tz = timezoneJS.timezone;
181 | _tz.loadingScheme = _tz.loadingSchemes.MANUAL_LOAD;
182 | _tz.loadZoneDataFromObject(tzdata);
183 | 
184 | var dt = new timezoneJS.Date(2006, 9, 29, 1, 59, 'America/Los_Angeles');
185 | ```
186 | 
187 | ## Pre-Parsed JSON Data
188 | 
189 | If you know beforehand what specific cities your users are going to be using, you can reduce load times specifically by creating a pre-parsed JSON data file containing only the timezone info for those specific cities.
190 | 
191 | The src directory contains 2 command-line JavaScript scripts that can generate this kind of JSON data:
192 | 
193 | - `node-preparse.js`: Uses Node to preparse and populate data.
194 | - `preparse.js`: This script requires the Rhino (Java) JavaScript engine to run, since the stock SpiderMonkey (C) engine doesn't come with file I/O capabilities.
195 | 
196 | Use the script like this:
197 | 
198 | ``` bash
199 | rhino preparse.js zoneFileDirectory [exemplarCities] > outputfile.json
200 | ```
201 | 
202 | Or:
203 | 
204 | ``` bash
205 | node node-preparse.js zoneFileDirectory [exemplarCities] > outputfile.json
206 | ```
207 | 
208 | The first parameter is the directory where the script can find the Olson zoneinfo files. The second (optional) param should be a comma-delimited list of timzeone cities to create the JSON data for. If that parameter isn't passed, the script will generate the JSON data for all the files.
209 | 
210 | ``` bash
211 | rhino preparse.js olson_files \
212 | "Asia/Tokyo, America/New_York, Europe/London" \
213 | > major_cities.json
214 | 
215 | rhino preparse.js olson_files > all_cities.json
216 | ```
217 | 
218 | Or:
219 | 
220 | ``` bash
221 | node node-preparse.js olson_files \
222 | "Asia/Tokyo, America/New_York, Europe/London" \
223 | > major_cities.json
224 | 
225 | node node-preparse.js olson_files > all_cities.json
226 | ```
227 | 
228 | Once you have your file of JSON data, set your loading scheme to `timezoneJS.timezone.loadingSchemes.MANUAL_LOAD`, and load the JSON data with `loadZoneJSONData`, like this:
229 | 
230 | ``` js
231 | var _tz = timezoneJS.timezone;
232 | _tz.loadingScheme = _tz.loadingSchemes.MANUAL_LOAD;
233 | _tz.loadZoneJSONData('/major_cities.json', true);
234 | ```
235 | 
236 | Since the limited set of data will be much smaller than any of the zoneinfo files, and the JSON data is deserialized with `eval` or `JSON.parse`, this method is significantly faster than the default setup. However, it only works if you know beforehand exactly what timezones you want to use.
237 | 
238 | ## Compressing
239 | 
240 | The Olson timezone data files are simple, space- and linefeed-delimited data. The abundance of whitespace means they compress very, very well.
241 | 
242 | If you plan to use `timezoneJS.Date` in a production Web app, it's highly recommended that you first strip the copious comments found in every Olson file, and serve compressed versions of the files to all browsers that can handle it. **(Note that IE6 reports itself as able to work with gzipped data, but has numerous problems with it.)**
243 | 
244 | Just to give you an idea of the difference -- merely stripping out the comments from the 'northamerica' file reduces its size by two-thirds -- from 103K to 32K. Gzipping the stripped file reduces it down to 6.5K -- probably smaller than most of the graphics in your app.
245 | 
246 | The `src` directory has a sample Ruby script that you can use to strip comments from Olson data files.
247 | 
248 | ## Development
249 | This project use [Jake](https://github.com/mde/jake) to build. In order to see available tasks, do `jake -T`. The build sequence is:
250 | 
251 | - `jake test:init`: Download and extract tz files to `lib/tz`.
252 | - `jake test`: Run `jasmine-node`.
253 | 
254 | Feel free to fork and modify at your own will.
255 | The source code is annotated and doc can be generated with `jake doc`.
256 | 
257 | ## License
258 | 
259 | 
260 | Copyright 2010 Matthew Eernisse (mde@fleegix.org) and Open Source Applications Foundation.
261 | 
262 | Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
263 | 
264 | Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
265 | 
266 | Credits: Ideas included from incomplete JS implementation of Olson parser, "XMLDAte" by Philippe Goetz (philippe.goetz@wanadoo.fr)
267 | 
268 | Contributions:
269 | 
270 | - Jan Niehusmann
271 | - Ricky Romero
272 | - Preston Hunt (prestonhunt@gmail.com)
273 | - Dov. B Katz (dov.katz@morganstanley.com)
274 | - Peter Bergström (pbergstr@mac.com)
275 | - Long Ho (@longlho)
276 | - Eugeny Loy (eugeny.loy@gmail.com)
277 | 


--------------------------------------------------------------------------------
/benchmarks/benchmark.js:
--------------------------------------------------------------------------------
 1 | var timezoneJS = require('../src/date')
 2 |   , fs = require('fs');
 3 | 
 4 | timezoneJS.timezone.transport = function (opts) {
 5 |   // No success handler, what's the point?
 6 |   if (opts.async) {
 7 |     if (typeof opts.success !== 'function') return;
 8 |     opts.error = opts.error || console.error;
 9 |     return fs.readFile(opts.url, 'utf8', function (err, data) {
10 |       return err ? opts.error(err) : opts.success(data);
11 |     });
12 |   }
13 |   return fs.readFileSync(opts.url, 'utf8');
14 | };
15 | 
16 | //Set up again
17 | timezoneJS.timezone.zoneFileBasePath = 'lib/tz';
18 | timezoneJS.timezone.init({ async: false });
19 | 
20 | console.time('Convert 5000 dates');
21 | var start = Date.now()
22 | , yearToMillis = 5 * 365 * 24 * 3600 * 1000
23 | , date;
24 | for (var i = 0; i < 5000; i++) {
25 |   date = new timezoneJS.Date(start - Math.random() * yearToMillis, 'America/New_York');
26 |   date.setTimezone('Europe/Minsk');
27 | }
28 | console.timeEnd('Convert 5000 dates');
29 | 
30 | console.time('Get 5000 same tzInfo');
31 | for (var i = 0; i < 5000; i++) {
32 |   timezoneJS.timezone.getTzInfo(new Date(), 'America/Chicago');
33 | }
34 | console.timeEnd('Get 5000 same tzInfo');


--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "timezone-js",
 3 |   "version": "0.4.11",
 4 |   "main": "src/date.js",
 5 |   "ignore": [
 6 |     "**/.*",
 7 |     "node_modules",
 8 |     "components"
 9 |   ]
10 | }


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "author": "Matthew Eernisse <mde@fleegix.org> (http://fleegix.org)",
 3 |   "contributors": [
 4 |     "Jan Niehusmann",
 5 |     "Ricky Romero",
 6 |     "Preston Hunt <prestonhunt@gmail.com>",
 7 |     "Dov. B Katz <dov.katz@morganstanley.com>",
 8 |     "Peter Bergström <pbergstr@mac.com>",
 9 |     "Long Ho <holevietlong@gmail.com> (http://www.longlho.me)"
10 |   ],
11 |   "name": "timezone-js",
12 |   "description": "JavaScript timezone library based on Olson timezone data",
13 |   "version": "0.4.11",
14 |   "main": "src/date.js",
15 |   "homepage": "https://github.com/mde/timezone-js",
16 |   "repository": {
17 |     "type": "git",
18 |     "url": "git://github.com/mde/timezone-js.git"
19 |   },
20 |   "scripts": {
21 |     "test": "./node_modules/jake/bin/cli.js test:cli"
22 |   },
23 |   "engines": {
24 |     "node": "*"
25 |   },
26 |   "dependencies": {},
27 |   "devDependencies": {
28 |     "jake": "0.7.x",
29 |     "jasmine-node": "latest"
30 |   }
31 | }


--------------------------------------------------------------------------------
/spec/date.spec.js:
--------------------------------------------------------------------------------
  1 | var TestUtils = require('./test-utils')
  2 | , timezoneJS = TestUtils.getTimezoneJS();
  3 | 
  4 | describe('timezoneJS.Date', function () {
  5 |   it('should correctly trim dates when date exceeds format length', function () {
  6 |     var date = new timezoneJS.Date(2011, 10, 22);
  7 |     expect(date.toString('yy-MM-dd')).toEqual('11-11-22')
  8 |   });
  9 | 
 10 |   it('should correctly pad dates when date is shorter than the format length', function () {
 11 |     var date = new timezoneJS.Date(2011, 3, 2);
 12 |     expect(date.toString('yyyy-MM-dd')).toEqual('2011-04-02')
 13 |   });
 14 | 
 15 |   it('should have correct format when initialized', function () {
 16 |     var date = new timezoneJS.Date();
 17 |     expect(date.toString()).toMatch(/[\d]{4}(-[\d]{2}){2}T([\d]{2}:){2}[\d]{2}.[\d]{3}/);
 18 |   });
 19 | 
 20 |   it('should have handled March correctly (not replacing h) when initialized', function () {
 21 |     var date = new timezoneJS.Date(2011, 2, 2, 11, 1, 1, 'Etc/UTC');
 22 |     expect(date.toString('MMMM')).toEqual('March');
 23 |   });
 24 | 
 25 |   it('should format string correctly in toISOString', function () {
 26 |     var date = new timezoneJS.Date();
 27 |     expect(date.toISOString()).toMatch(/[\d]{4}(-[\d]{2}){2}T([\d]{2}:){2}[\d]{2}.[\d]{3}/);
 28 |   });
 29 | 
 30 |   it('should get date correctly from UTC (2011-10-28T12:44:22.172000000)', function () {
 31 |     var date = new timezoneJS.Date(2011, 9, 28, 12, 44, 22, 172,'Etc/UTC');
 32 |     expect(date.getTime()).toEqual(1319805862172);
 33 |     expect(date.toString()).toEqual('2011-10-28T12:44:22.172');
 34 |     expect(date.toString('yyyy-MM-dd')).toEqual('2011-10-28');
 35 |   });
 36 | 
 37 |   it('should format 2011-10-28T12:44:22.172 UTC to different formats correctly', function () {
 38 |     var date = new timezoneJS.Date(2011,9,28,12,44,22,172,'Etc/UTC');
 39 |     expect(date.toString('MMM dd yyyy')).toEqual('Oct 28 2011');
 40 |     expect(date.toString('MMM dd yyyy HH:mm:ss k')).toEqual('Oct 28 2011 12:44:22 PM');
 41 |     expect(date.toString('MMM dd yyyy HH:mm:ss k Z')).toEqual('Oct 28 2011 12:44:22 PM UTC');
 42 |   });
 43 | 
 44 |   it('should format 2011-10-28T12:44:22.172 UTC to different formats and tz correctly', function () {
 45 |     var date = new timezoneJS.Date(2011,9,28,12,44,22,172,'Etc/UTC');
 46 |     expect(date.toString('MMM dd yyyy', 'America/New_York')).toEqual('Oct 28 2011');
 47 |     expect(date.toString('MMM dd yyyy HH:mm:ss k Z', 'America/New_York')).toEqual('Oct 28 2011 08:44:22 AM EDT');
 48 |     expect(date.toString('MMM dd yyyy HH:mm:ss k Z', 'Asia/Shanghai')).toEqual('Oct 28 2011 08:44:22 PM CST');
 49 |   });
 50 | 
 51 |   it('should format 2011-02-28T12:44:22.172 UTC (before daylight) to different formats and tz correctly', function () {
 52 |     var date = new timezoneJS.Date(2011,1,28,12,44,22,172,'Etc/UTC');
 53 |     expect(date.toString('MMM dd yyyy HH:mm:ss k Z', 'America/New_York')).toEqual('Feb 28 2011 07:44:22 AM EST');
 54 |     expect(date.toString('MMM dd yyyy HH:mm:ss k Z', 'Indian/Cocos')).toEqual('Feb 28 2011 07:14:22 PM CCT');
 55 |   });
 56 | 
 57 |   it('should format the Unix Epoch UTC to different formats and tz correctly', function () {
 58 |     var date = new timezoneJS.Date(1970,0,1,0,0,0,0,'Etc/UTC');
 59 |     expect(date.toString('MMM dd yyyy HH:mm:ss k Z', 'Europe/Kaliningrad')).toEqual('Jan 01 1970 03:00:00 AM MSK');
 60 |   });
 61 | 
 62 |   it('should use a default format with the given tz', function () {
 63 |     var date = new timezoneJS.Date(2012, 7, 30, 10, 56, 0, 0, 'America/Los_Angeles');
 64 |     expect(date.toString(null, 'Etc/UTC')).toEqual(date.toString('yyyy-MM-ddTHH:mm:ss.SSS', 'Etc/UTC'));
 65 |     expect(date.toString(null, 'America/New_York')).toEqual(date.toString('yyyy-MM-ddTHH:mm:ss.SSS', 'America/New_York'));
 66 |   });
 67 | 
 68 |   it('should convert dates from UTC to a timezone correctly', function () {
 69 |     var date = new timezoneJS.Date(2011,1,28,12,44,22,172,'Etc/UTC');
 70 |     date.setTimezone('America/Los_Angeles');
 71 |     expect(date.toString('MMM dd yyyy HH:mm:ss k Z')).toEqual('Feb 28 2011 04:44:22 AM PST');
 72 |     expect(date.getTime()).toEqual(1298897062172);
 73 |     expect(date.getHours()).toEqual(4);
 74 |   });
 75 | 
 76 |   it('should convert dates from a timezone to UTC correctly', function () {
 77 |     var date = new timezoneJS.Date(2007, 9, 31, 10, 30, 22, 'America/Los_Angeles');
 78 |     date.setTimezone('Etc/GMT');
 79 |     expect(date.getTime()).toEqual(1193851822000);
 80 |     expect(date.toString('MMM dd yyyy HH:mm:ss k Z')).toEqual('Oct 31 2007 05:30:22 PM UTC');
 81 |     expect(date.getHours()).toEqual(17);
 82 |   });
 83 | 
 84 |   it('should convert dates from one timezone to another correctly', function () {
 85 |     var dtA = new timezoneJS.Date(2007, 9, 31, 10, 30, 'America/Los_Angeles');
 86 | 
 87 |     dtA.setTimezone('America/Chicago');
 88 |     expect(dtA.getTime()).toEqual(1193851800000);
 89 |     expect(dtA.toString()).toEqual('2007-10-31T12:30:00.000');
 90 |   });
 91 | 
 92 |   it('should convert dates from unix time properly', function () {
 93 |     var dtA = new timezoneJS.Date(1193851800000);
 94 | 
 95 |     dtA.setTimezone('America/Chicago');
 96 |     expect(dtA.getTime()).toEqual(1193851800000);
 97 |     expect(dtA.toString()).toEqual('2007-10-31T12:30:00.000');
 98 |   });
 99 | 
100 |   it('should output toISOString correctly', function () {
101 |     var dtA = new Date()
102 |     , dt = new timezoneJS.Date();
103 | 
104 |     dtA.setTime(dtA.getTime());
105 |     expect(dt.getTime()).toEqual(dtA.getTime());
106 |     expect(dt.toISOString()).toEqual(dtA.toISOString());
107 |   });
108 | 
109 |   it('should output toGMTString correctly', function () {
110 |     var dtA = new Date()
111 |     , dt = new timezoneJS.Date();
112 | 
113 |     dtA.setTime(dtA.getTime());
114 |     expect(dt.getTime()).toEqual(dtA.getTime());
115 |     expect(dt.toGMTString()).toEqual(dtA.toGMTString());
116 |   });
117 | 
118 | 
119 |   it('should output toJSON correctly', function () {
120 |     var dtA = new Date()
121 |     , dt = new timezoneJS.Date();
122 | 
123 |     dtA.setTime(dtA.getTime());
124 |     expect(dt.getTime()).toEqual(dtA.getTime());
125 |     expect(dt.toJSON()).toEqual(dtA.toJSON());
126 |   });
127 | 
128 |   it('should take in millis as constructor', function () {
129 |     var dtA = new Date(0)
130 |     , dt = new timezoneJS.Date(dtA.getTime());
131 | 
132 |     expect(dt.getTime()).toEqual(dtA.getTime());
133 |     expect(dt.toJSON()).toEqual(dtA.toJSON());
134 |   });
135 | 
136 |   it('should take in Date object as constructor', function () {
137 |     var dtA = new Date(0)
138 |     , dt = new timezoneJS.Date(dtA);
139 | 
140 |     expect(dt.getTime()).toEqual(dtA.getTime());
141 |     expect(dt.toJSON()).toEqual(dtA.toJSON());
142 |   });
143 | 
144 |   it('should take in millis and tz as constructor', function () {
145 |     var dtA = new Date(0)
146 |     , dt = new timezoneJS.Date(dtA.getTime(), 'Asia/Bangkok');
147 | 
148 |     expect(dt.getTime()).toEqual(0);
149 |   });
150 | 
151 |   it('should take in Date object as constructor', function () {
152 |     var dtA = new Date(0)
153 |     , dt = new timezoneJS.Date(dtA, 'Asia/Bangkok');
154 | 
155 |     expect(dt.getTime()).toEqual(0);
156 |   });
157 | 
158 |   it('should take in String and Asia/Bangkok as constructor', function () {
159 |     //This is a RFC 3339 UTC string format
160 |     var dt = new timezoneJS.Date('2012-01-01T15:00:00.000', 'Asia/Bangkok');
161 | 
162 |     expect(dt.toString()).toEqual('2012-01-01T22:00:00.000');
163 |     expect(dt.toString('yyyy-MM-ddTHH:mm:ss.SSS', 'America/New_York')).toEqual('2012-01-01T10:00:00.000');
164 |     expect(dt.toString('yyyy-MM-ddTHH:mm:ss.SSS')).toEqual('2012-01-01T22:00:00.000');
165 |   });
166 | 
167 |   it('should take in String and Etc/UTC as constructor', function () {
168 |     var dt = new timezoneJS.Date('2012-01-01T15:00:00.000', 'Etc/UTC');
169 | 
170 |     expect(dt.toString('yyyy-MM-ddTHH:mm:ss.SSS', 'America/New_York')).toEqual('2012-01-01T10:00:00.000');
171 |     expect(dt.toString('yyyy-MM-ddTHH:mm:ss.SSS')).toEqual('2012-01-01T15:00:00.000');
172 | 
173 |   });
174 | 
175 |   it('should take in String (other format) and Etc/UTC as constructor', function () {
176 |     var dt = new timezoneJS.Date('2013/06/18 10:37', 'Etc/UTC');
177 | 
178 |     expect(dt.toString('yyyy/MM/dd HH:mm', 'America/Los_Angeles')).toEqual('2013/06/18 03:37');
179 |   });
180 | 
181 |   it('should take in String (other format) and Europe/Athens as constructor', function () {
182 |     var dt = new timezoneJS.Date('2013/06/18 10:37', 'Europe/Athens');
183 | 
184 |     expect(dt.toString('yyyy/MM/dd HH:mm', 'America/Los_Angeles')).toEqual('2013/06/18 00:37');
185 |   });
186 | 
187 |   it('should take in String as constructor', function () {
188 |     var dtA = new Date()
189 |     , dt = new timezoneJS.Date(dtA.toJSON());
190 | 
191 |     expect(dt.toJSON()).toEqual(dtA.toJSON());
192 |   });
193 | 
194 | 
195 |   it('should be able to set hours', function () {
196 |     var dtA = new Date(0)
197 |     , dt = new timezoneJS.Date(0, 'Etc/UTC');
198 | 
199 |     dt.setHours(6);
200 |     expect(dt.getHours()).toEqual(6);
201 |   });
202 | 
203 |   it('should be able to set date without altering others', function () {
204 |     var dt = new timezoneJS.Date(2012, 2, 2, 5, 0, 0, 0, 'America/Los_Angeles')
205 |     , dt2 = new timezoneJS.Date(2011, 4, 15, 23, 0, 0, 0, 'Asia/Bangkok');
206 | 
207 |     var hours = dt.getHours();
208 |     dt.setDate(1);
209 |     expect(dt.getHours()).toEqual(hours);
210 | 
211 |     hours = dt2.getHours();
212 |     dt2.setDate(2);
213 |     expect(dt2.getHours()).toEqual(hours);
214 |   });
215 | 
216 |   it('should be able to set UTC date without altering others', function () {
217 |     var dt = new timezoneJS.Date(2012, 2, 2, 5, 0, 0, 0, 'America/Los_Angeles');
218 | 
219 |     var hours = dt.getUTCHours();
220 |     dt.setUTCDate(1);
221 |     expect(dt.getUTCHours()).toEqual(hours);
222 |   });
223 | 
224 | 
225 |   it('should adjust daylight saving correctly', function () {
226 |     var dt1 = new timezoneJS.Date(2012, 2, 11, 3, 0, 0, 'America/Chicago');
227 |     expect(dt1.getTimezoneAbbreviation()).toEqual('CDT');
228 |     expect(dt1.getTimezoneOffset()).toEqual(300);
229 |     var dt2 = new timezoneJS.Date(2012, 2, 11, 1, 59, 59, 'America/Chicago');
230 | 
231 |     expect(dt2.getTimezoneAbbreviation()).toEqual('CST');
232 |     expect(dt2.getTimezoneOffset()).toEqual(360);
233 |   });
234 | 
235 |   it('should be able to clone itself', function () {
236 |     var dt = new timezoneJS.Date(0, 'America/Chicago')
237 |     , dtA = dt.clone();
238 | 
239 |     expect(dt.getTime()).toEqual(dtA.getTime());
240 |     expect(dt.toString()).toEqual(dtA.toString());
241 |     expect(dt.getTimezoneOffset()).toEqual(dtA.getTimezoneOffset());
242 |     expect(dt.getTimezoneAbbreviation()).toEqual(dtA.getTimezoneAbbreviation());
243 |   });
244 | 
245 |   it('should output 1955-10-30 00:00:00 America/New_York as EDT', function () {
246 |     var dt = new timezoneJS.Date(1955, 9, 30, 0, 0, 0, 'America/New_York');
247 |     expect(dt.getTimezoneOffset()).toEqual(240);
248 |   });
249 | 
250 |   it('should handle Pacific/Apia correctly', function () {
251 |     var dt = new timezoneJS.Date(2011, 11, 29, 23, 59, 59, 'Pacific/Apia');
252 |     var t = dt.getTime() + 1000;
253 |     dt.setTime(t);
254 |     expect(dt.toString()).toEqual('2011-12-31T00:00:00.000');
255 |     expect(dt.getTime()).toEqual(t);
256 |   });
257 | 
258 |   // Years
259 |   it("accepts an optional parameter for month in setUTCFullYear", function() {
260 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "Etc/UTC");
261 |     expect(date.getUTCMonth()).toEqual(11);
262 |     expect(date.getUTCDate()).toEqual(31);
263 |     date.setUTCFullYear(2012, 1);
264 |     //Febuary does not have a 31st, thus we should wrap to march
265 |     expect(date.getUTCMonth()).toEqual(2);
266 |     expect(date.getUTCDate()).toEqual(2);
267 |   });
268 | 
269 |   it("accepts a second optional parameter for date in setUTCFullYear", function() {
270 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "Etc/UTC");
271 |     expect(date.getUTCMonth()).toEqual(11);
272 |     expect(date.getUTCDate()).toEqual(31);
273 |     date.setUTCFullYear(2012, 1, 1);
274 |     //Do not wrap to March because we are setting the date as well
275 |     expect(date.getUTCMonth()).toEqual(1);
276 |     expect(date.getUTCDate()).toEqual(1);
277 |   });
278 | 
279 |   it("accepts an optional parameter for month in setFullYear", function() {
280 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "America/New_York");
281 |     expect(date.getMonth()).toEqual(11);
282 |     expect(date.getDate()).toEqual(31);
283 |     date.setFullYear(2012, 1);
284 |     //Febuary does not have a 31st, thus we should wrap to march
285 |     expect(date.getMonth()).toEqual(2);
286 |     expect(date.getDate()).toEqual(2);
287 |   });
288 | 
289 |   it("accepts a second optional parameter for date in setFullYear", function() {
290 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "America/New_York");
291 |     expect(date.getMonth()).toEqual(11);
292 |     expect(date.getDate()).toEqual(31);
293 |     date.setFullYear(2012, 1, 1);
294 |     //Do not wrap to March because we are setting the date as well
295 |     expect(date.getMonth()).toEqual(1);
296 |     expect(date.getDate()).toEqual(1);
297 |   });
298 | 
299 |   // Months
300 |   it("accepts an optional parameter for date in setUTCMonths", function() {
301 |     var date = new timezoneJS.Date(2000, 7, 14, 0, 0, 0, "Etc/UTC");
302 |     expect(date.getUTCMonth()).toEqual(7);
303 |     expect(date.getUTCDate()).toEqual(14);
304 |     date.setUTCMonth(1, 5);
305 |     expect(date.getUTCMonth()).toEqual(1);
306 |     expect(date.getUTCDate()).toEqual(5);
307 |     date.setUTCMonth(0, 0);
308 |     expect(date.getUTCMonth()).toEqual(11);
309 |     expect(date.getUTCDate()).toEqual(31);
310 |   });
311 | 
312 |   it("accepts an optional parameter for date in setMonths", function() {
313 |     var date = new timezoneJS.Date(2000, 7, 14, 0, 0, 0, "America/New_York");
314 |     expect(date.getMonth()).toEqual(7);
315 |     expect(date.getDate()).toEqual(14);
316 |     date.setMonth(1, 5);
317 |     expect(date.getMonth()).toEqual(1);
318 |     expect(date.getDate()).toEqual(5);
319 |     date.setMonth(0, 0);
320 |     expect(date.getMonth()).toEqual(11);
321 |     expect(date.getDate()).toEqual(31);
322 |   });
323 | 
324 |   // Hours
325 |   it("accepts an optional parameter for minutes in setUTCHours", function() {
326 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "Etc/UTC");
327 |     expect(date.getUTCMinutes()).toEqual(0);
328 |     date.setUTCHours(0, 1);
329 |     expect(date.getUTCMinutes()).toEqual(1);
330 |     date.setUTCHours(0, 0);
331 |     expect(date.getUTCMinutes()).toEqual(0);
332 |   });
333 | 
334 |   it("accepts an optional parameter for seconds in setUTCHours", function() {
335 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "Etc/UTC");
336 |     expect(date.getUTCSeconds()).toEqual(0);
337 |     date.setUTCHours(0, 1, 2);
338 |     expect(date.getUTCSeconds()).toEqual(2);
339 |     date.setUTCHours(0, 0, 0);
340 |     expect(date.getUTCSeconds()).toEqual(0);
341 |   });
342 | 
343 |   it("accepts an optional parameter for milliseconds in setUTCHours", function() {
344 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "Etc/UTC");
345 |     expect(date.getUTCMilliseconds()).toEqual(0);
346 |     date.setUTCHours(0, 1, 2, 3);
347 |     expect(date.getUTCMilliseconds()).toEqual(3);
348 |     date.setUTCHours(0, 0, 0, 0);
349 |     expect(date.getUTCMilliseconds()).toEqual(0);
350 |   });
351 | 
352 |   it("accepts an optional parameter for minutes in setHours", function() {
353 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "America/New_York");
354 |     expect(date.getMinutes()).toEqual(0);
355 |     date.setHours(0, 1);
356 |     expect(date.getMinutes()).toEqual(1);
357 |     date.setHours(0, 0);
358 |     expect(date.getMinutes()).toEqual(0);
359 |   });
360 | 
361 |   it("accepts an optional parameter for seconds in setHours", function() {
362 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "America/New_York");
363 |     expect(date.getSeconds()).toEqual(0);
364 |     date.setHours(0, 1, 2);
365 |     expect(date.getSeconds()).toEqual(2);
366 |     date.setHours(0, 0, 0);
367 |     expect(date.getSeconds()).toEqual(0);
368 |   });
369 | 
370 |   it("accepts an optional parameter for milliseconds in setHours", function() {
371 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "America/New_York");
372 |     expect(date.getMilliseconds()).toEqual(0);
373 |     date.setHours(0, 1, 2, 3);
374 |     expect(date.getMilliseconds()).toEqual(3);
375 |     date.setHours(0, 0, 0, 0);
376 |     expect(date.getMilliseconds()).toEqual(0);
377 |   });
378 | 
379 |   // Minutes
380 |   it("accepts an optional parameter for seconds in setUTCMinutes", function() {
381 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "Etc/UTC");
382 |     expect(date.getUTCSeconds()).toEqual(0);
383 |     date.setUTCMinutes(0, 1);
384 |     expect(date.getUTCSeconds()).toEqual(1);
385 |     date.setUTCMinutes(0, 0);
386 |     expect(date.getUTCSeconds()).toEqual(0);
387 |   });
388 | 
389 |   it("accepts an optional parameter for milliseconds in setUTCMinutes", function() {
390 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "Etc/UTC");
391 |     expect(date.getUTCMilliseconds()).toEqual(0);
392 |     date.setUTCMinutes(0, 1, 2);
393 |     expect(date.getUTCMilliseconds()).toEqual(2);
394 |     date.setUTCMinutes(0, 0, 0);
395 |     expect(date.getUTCMilliseconds()).toEqual(0);
396 |   });
397 | 
398 |   it("accepts an optional parameter for seconds in setMinutes", function() {
399 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "America/New_York");
400 |     expect(date.getSeconds()).toEqual(0);
401 |     date.setMinutes(0, 1);
402 |     expect(date.getSeconds()).toEqual(1);
403 |     date.setMinutes(0, 0);
404 |     expect(date.getSeconds()).toEqual(0);
405 |   });
406 | 
407 |   it("accepts an optional parameter for milliseconds in setMinutes", function() {
408 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "America/New_York");
409 |     expect(date.getMilliseconds()).toEqual(0);
410 |     date.setMinutes(0, 1, 2);
411 |     expect(date.getMilliseconds()).toEqual(2);
412 |     date.setMinutes(0, 0, 0);
413 |     expect(date.getMilliseconds()).toEqual(0);
414 |   });
415 | 
416 |   // Seconds
417 |   it("accepts an optional parameter for milliseconds in setUTCSeconds", function() {
418 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "Etc/UTC");
419 |     expect(date.getUTCMilliseconds()).toEqual(0);
420 |     date.setUTCSeconds(0, 1);
421 |     expect(date.getUTCMilliseconds()).toEqual(1);
422 |     date.setUTCSeconds(0, 0);
423 |     expect(date.getUTCMilliseconds()).toEqual(0);
424 |   });
425 | 
426 |   it("accepts an optional parameter for milliseconds in setSeconds", function() {
427 |     var date = new timezoneJS.Date(2000, 11, 31, 0, 0, 0, "America/New_York");
428 |     expect(date.getMilliseconds()).toEqual(0);
429 |     date.setSeconds(0, 1);
430 |     expect(date.getMilliseconds()).toEqual(1);
431 |     date.setSeconds(0, 0);
432 |     expect(date.getMilliseconds()).toEqual(0);
433 |   });
434 | 
435 | 
436 |   it("handles static dst offsets in Zones like '1:00' instead of DST rule references.", function(){
437 |     var date = new timezoneJS.Date(Date.UTC(2012, 2, 1, 0, 0, 0, 0), "Pacific/Apia");
438 |     expect(date.getTimezoneOffset()).toBe(-840);
439 |     expect(date.toString("yyyy-MM-dd HH:mm:ss Z")).toBe("2012-03-01 14:00:00 WSDT");
440 |   });
441 | 
442 |   it("returns the milis value for setTime", function() {
443 |     var date = new timezoneJS.Date("America/New_York");
444 |     expect(date.setTime(123456789)).toEqual(123456789);
445 |   });
446 | 
447 |   it("returns the milis value for every set* command", function() {
448 |     milis = 1193851822000
449 |     var date = new timezoneJS.Date(milis, "America/New_York");
450 |     expect(date.setFullYear(date.getFullYear())).toEqual(milis);
451 |     expect(date.setMonth(date.getMonth())).toEqual(milis);
452 |     expect(date.setDate(date.getDate())).toEqual(milis);
453 |     expect(date.setHours(date.getHours())).toEqual(milis);
454 |     expect(date.setMinutes(date.getMinutes())).toEqual(milis);
455 |     expect(date.setSeconds(date.getSeconds())).toEqual(milis);
456 |     expect(date.setMilliseconds(date.getMilliseconds())).toEqual(milis);
457 |   });
458 | 
459 |   it("returns the milis value for every setUTC* command", function() {
460 |     milis = 1193851822000
461 |     var date = new timezoneJS.Date(milis, "America/New_York");
462 |     expect(date.setUTCFullYear(date.getUTCFullYear())).toEqual(milis);
463 |     expect(date.setUTCMonth(date.getUTCMonth())).toEqual(milis);
464 |     expect(date.setUTCDate(date.getUTCDate())).toEqual(milis);
465 |     expect(date.setUTCHours(date.getUTCHours())).toEqual(milis);
466 |     expect(date.setUTCMinutes(date.getUTCMinutes())).toEqual(milis);
467 |     expect(date.setUTCSeconds(date.getUTCSeconds())).toEqual(milis);
468 |     expect(date.setUTCMilliseconds(date.getUTCMilliseconds())).toEqual(milis);
469 |   });
470 | 
471 |   it("handles getYear appropriately strangely (to spec)", function() {
472 |     // http://www.ecma-international.org/ecma-262/5.1/#sec-B.2.4
473 |     var date = new timezoneJS.Date(1998, 11, 31, 0, 0, 0, "America/New_York");
474 |     expect(date.getYear()).toEqual(98);
475 |     date.setFullYear(2013);
476 |     expect(date.getYear()).toEqual(113);
477 |   });
478 | 
479 |   it("handles setYear appropriately strangely (to spec)", function() {
480 |     // http://www.ecma-international.org/ecma-262/5.1/#sec-B.2.5
481 |     var date = new timezoneJS.Date(2001, 11, 31, 0, 0, 0, "America/New_York");
482 |     date.setYear(98)
483 |     expect(date.getFullYear()).toEqual(1998);
484 |     date.setYear(2003);
485 |     expect(date.getFullYear()).toEqual(2003);
486 |   });
487 | 
488 |   it('Represents hours in 24 hour format', function () {
489 |     for (var i = 0; i < 24; i ++) {
490 |       var time_value = new timezoneJS.Date(2013, 1, 1, i, 0, 0, 0, "America/Chicago");
491 |       expect(time_value.toString("H")).toEqual(i.toString());
492 |     }
493 |   });
494 | 
495 |   xit('Represents hours in 12 hour format by k side effect', function () {
496 |     for (var i = 0; i < 24; i ++) {
497 |       var ampm  =  i >= 12 ? "PM" : "AM";
498 |       var hour = (i % 12);
499 |       hour = (hour === 0) ? '12' : hour.toString();
500 |       zhour = hour > 9 ? hour.toString() : '0' + hour;
501 | 
502 |       var time_value = new timezoneJS.Date(2013, 1, 1, i, 0, 0, 0, "America/Chicago");
503 |       expect(time_value.toString("H k")).toEqual(hour + " " + ampm);
504 |       expect(time_value.toString("HH k")).toEqual(zhour + " " + ampm);
505 |     }
506 |   });
507 | 
508 |   it('Represents hours in single digit 12 hour format', function () {
509 |     for (var i = 0; i < 24; i ++) {
510 |       var ampm  =  i >= 12 ? "PM" : "AM";
511 |       var hour = (i % 12);
512 |       hour = (hour === 0) ? '12' : hour.toString();
513 |       zhour = hour > 9 ? hour.toString() : '0' + hour;
514 | 
515 |       var time_value = new timezoneJS.Date(2013, 1, 1, i, 0, 0, 0, "America/Chicago");
516 |       expect(time_value.toString("h k")).toEqual(hour + " " + ampm);
517 |       expect(time_value.toString("hh k")).toEqual(zhour + " " + ampm);
518 |     }
519 |   });
520 | 
521 |   it('should throw an exception when initialized without "new"', function () {
522 |     var init = function() {
523 |       var date = timezoneJS.Date();
524 |     };
525 |     expect(init).toThrow();
526 |   });
527 | 
528 |   it('should throw an exception when initialized with another Date when missing "new"', function () {
529 |     var d = new timezoneJS.Date();
530 |     var init = function() {
531 |       var k = timezoneJS.Date(d);
532 |     };
533 |     expect(init).toThrow();
534 |   });
535 | 
536 |   it('should take in year and month as constructor correctly', function () {
537 |     var d = new timezoneJS.Date( 2011, 8, "Etc/UTC");
538 |     expect( d.getMonth()).toEqual(8);
539 |   });
540 | 
541 |   it('should format string correctly in toDateString', function () {
542 |     var date = new timezoneJS.Date();
543 |     expect(date.toDateString()).toMatch(/^[\w]{3}[\s][\w]{3}[\s][\d]{2}[\s][\d]{4}$/);
544 |   });
545 | 
546 |   it('should correctly convert date in toDateString', function () {
547 |     var date = new timezoneJS.Date(2011, 3, 2);
548 |     expect(date.toDateString()).toEqual('Sat Apr 02 2011');
549 |   });
550 | 
551 |   it('should format string correctly in toTimeString', function () {
552 |     var date = new timezoneJS.Date();
553 |     expect(date.toTimeString()).toMatch(/^[\d]{1,2}:[\d]{2}[\s][\w]{2}$/);
554 |   });
555 | 
556 |   it('should correctly convert date to time in toTimeString', function () {
557 |     var date = new timezoneJS.Date(2011, 3, 2);
558 |     expect(date.toTimeString()).toEqual('0:00 AM');
559 |   });
560 | 
561 |   it('should work with timezones containing - symbol', function () {
562 |     var d = new timezoneJS.Date(0, "Etc/GMT-5");
563 |     expect(d.getMonth().toString()).not.toEqual('NaN');
564 |   });
565 | 
566 |   it('should return timezoneOffset as number', function () {
567 |     expect(new timezoneJS.Date(2014, 1, 1, 2, 0, 0, 0, 'Asia/Kolkata').getTimezoneOffset()).toEqual(-330);
568 |   });
569 | });
570 | 


--------------------------------------------------------------------------------
/spec/test-utils.js:
--------------------------------------------------------------------------------
 1 | var fs = require('fs');
 2 | (function () {
 3 |   var root = this;
 4 | 
 5 |   var TestUtils = {};
 6 |   if (typeof exports !== 'undefined') {
 7 |     TestUtils = exports;
 8 |   } else {
 9 |     TestUtils = root.TestUtils = {};
10 |   }
11 | 
12 |   var init = function (timezoneJS, options) {
13 |     var opts = {
14 |       async: false,
15 |       loadingScheme: timezoneJS.timezone.loadingSchemes.LAZY_LOAD
16 |     };
17 |     for (var k in (options || {})) {
18 |       opts[k] = options[k];
19 |     }
20 |     
21 |     timezoneJS.timezone.loadingScheme = opts.loadingScheme;
22 |     timezoneJS.timezone.defaultZoneFile = opts.defaultZoneFile;
23 |     if (opts.loadingScheme !== timezoneJS.timezone.loadingSchemes.MANUAL_LOAD) {
24 |       //Set up again
25 |       timezoneJS.timezone.zoneFileBasePath = 'lib/tz';
26 |       timezoneJS.timezone.init(opts);
27 |     }
28 |     
29 |     return timezoneJS;
30 |   };
31 | 
32 |   TestUtils.getTimezoneJS = function (options) {
33 |     //Delete date.js from require cache to force it to reload
34 |     for (var k in require.cache) {
35 |       if (k.indexOf('date.js') > -1) {
36 |         delete require.cache[k];
37 |       }
38 |     }
39 |     return init(require('../src/date'), options);
40 |   };
41 | 
42 |   TestUtils.parseISO = function (timestring) {
43 |     var pat = '^(?:([+-]?[0-9]{4,})(?:-([0-9]{2})(?:-([0-9]{2}))?)?)?' +
44 |       '(?:T(?:([0-9]{2})(?::([0-9]{2})(?::([0-9]{2})(?:\\.' +
45 |       '([0-9]{3}))?)?)?)?(Z|[-+][0-9]{2}:[0-9]{2})?)?$';
46 |     var match = timestring.match(pat);
47 |     if (match) {
48 |       var parts = {
49 |         year: match[1] || 0,
50 |         month:  match[2] || 1,
51 |         day:  match[3] || 1,
52 |         hour:  match[4] || 0,
53 |         minute:  match[5] || 0,
54 |         second:  match[6] || 0,
55 |         milli:  match[7] || 0,
56 |         offset:  match[8] || "Z"
57 |       };
58 | 
59 |       var utcDate = Date.UTC(parts.year, parts.month-1, parts.day,
60 |         parts.hour, parts.minute, parts.second, parts.milli);
61 | 
62 |       if (parts.offset !== "Z") {
63 |         match = parts.offset.match('([-+][0-9]{2})(?::([0-9]{2}))?');
64 |         if (!match) {
65 |           return NaN;
66 |         }
67 |         var offset = match[1]*60*60*1000+(match[2] || 0)*60*1000;
68 |         utcDate -= offset;
69 |       }
70 |       return new Date(utcDate);
71 |     }
72 |     return null;
73 |   };
74 | }).call(this);
75 | 


--------------------------------------------------------------------------------
/spec/tz.async.spec.js:
--------------------------------------------------------------------------------
 1 | var TestUtils = require('./test-utils')
 2 | , parseISO = TestUtils.parseISO
 3 | , date = require('../src/date');
 4 | 
 5 | describe('TimezoneJS', function () {
 6 |   it('should async preload everything correctly', function () {
 7 | 
 8 |     var i = 0
 9 |     , timezoneJS
10 |     , sampleTz;
11 |     runs(function () {
12 |       timezoneJS = TestUtils.getTimezoneJS({
13 |         loadingScheme: date.timezone.loadingSchemes.PRELOAD_ALL,
14 |         async: true,
15 |         callback: function () {
16 |           //Make sure more than 1 zone is loaded
17 |           for (var k in timezoneJS.timezone.loadedZones) {
18 |             i++;
19 |           }
20 |           sampleTz = timezoneJS.timezone.getTzInfo(new Date(), 'Asia/Bangkok');
21 |         }
22 |       });
23 |     });
24 | 
25 |     waitsFor(function () {
26 |       return i > 0;
27 |     }, 'zones should be loaded', 100);
28 |     runs(function () {
29 |       expect(timezoneJS.timezone.loadingScheme).toEqual(date.timezone.loadingSchemes.PRELOAD_ALL);
30 | 
31 |       expect(i).toEqual(timezoneJS.timezone.zoneFiles.length);
32 |       expect(sampleTz).toBeDefined();
33 |       expect(sampleTz.tzAbbr).toEqual('ICT');
34 | 
35 |     });
36 |   });
37 | });
38 | 


--------------------------------------------------------------------------------
/spec/tz.default.spec.js:
--------------------------------------------------------------------------------
 1 | var TestUtils = require('./test-utils')
 2 |   , parseISO = TestUtils.parseISO
 3 |   , date = require('../src/date')
 4 |   , timezoneJS = TestUtils.getTimezoneJS({
 5 |     defaultZoneFile: 'asia'
 6 |   });
 7 | describe('TimezoneJS', function () {
 8 |   it('should preload everything correctly', function () {
 9 |     expect(timezoneJS.timezone.loadingScheme).toEqual(date.timezone.loadingSchemes.LAZY_LOAD);
10 |     expect(timezoneJS.timezone.loadedZones.asia).toBe(true);
11 |     sampleTz = timezoneJS.timezone.getTzInfo(new Date(), 'Asia/Bangkok');
12 |     expect(sampleTz).toBeDefined();
13 |     expect(sampleTz.tzAbbr).toEqual('ICT');
14 |   });
15 | 
16 |   it('should load an unloaded zone file linked from the backward file', function () {
17 |     sampleTz = timezoneJS.timezone.getTzInfo(new Date(), 'Antarctica/South_Pole');
18 |     expect(timezoneJS.timezone.loadedZones).toEqual({ asia: true, antarctica: true, backward: true, australasia: true });
19 |     expect(sampleTz.tzAbbr).toEqual('NZDT');
20 |   });
21 | 
22 | });
23 | 


--------------------------------------------------------------------------------
/spec/tz.manual.spec.js:
--------------------------------------------------------------------------------
 1 | var TestUtils = require('./test-utils')
 2 |   , parseISO = TestUtils.parseISO
 3 |   , date = require('../src/date')
 4 |   , timezoneJS = TestUtils.getTimezoneJS({
 5 |     loadingScheme: date.timezone.loadingSchemes.MANUAL_LOAD
 6 |   });
 7 | describe('TimezoneJS', function () {
 8 |   xit('should manually load everything correctly', function () {
 9 |     var i = 0
10 |       , sampleTz;
11 | 
12 |     expect(timezoneJS.timezone.loadingScheme).toEqual(date.timezone.loadingSchemes.MANUAL_LOAD);
13 |     //Let's load some stuff
14 |     timezoneJS.timezone.loadZoneJSONData('lib/all_cities.json', true);
15 |     expect(Object.keys(timezoneJS.timezone.zones).length > 100).toBeTruthy();
16 |     sampleTz = timezoneJS.timezone.getTzInfo(new Date(), 'Asia/Bangkok');
17 |     expect(sampleTz).toBeDefined();
18 |     expect(sampleTz.tzAbbr).toEqual('ICT');
19 |     dt = new timezoneJS.Date();
20 |     dt.setTimezone('America/Chicago');
21 |     expect(dt.getTimezoneAbbreviation()).toMatch(/C(S|D)T/);
22 |     dt.setTimezone('America/New_York');
23 |     expect(dt.getTimezoneAbbreviation()).toMatch(/E(S|D)T/);
24 |   });
25 | });
26 | 


--------------------------------------------------------------------------------
/spec/tz.preload.spec.js:
--------------------------------------------------------------------------------
 1 | var TestUtils = require('./test-utils')
 2 |   , parseISO = TestUtils.parseISO
 3 |   , date = require('../src/date')
 4 |   , timezoneJS = TestUtils.getTimezoneJS({
 5 |     loadingScheme: date.timezone.loadingSchemes.PRELOAD_ALL
 6 |   });
 7 | describe('TimezoneJS', function () {
 8 |   it('should preload everything correctly', function () {
 9 |     var i = 0
10 |       , sampleTz;
11 |     expect(timezoneJS.timezone.loadingScheme).toEqual(date.timezone.loadingSchemes.PRELOAD_ALL);
12 |     //Make sure more than 1 zone is loaded
13 |     for (var k in timezoneJS.timezone.loadedZones) {
14 |       i++;
15 |     }
16 |     expect(i).toEqual(timezoneJS.timezone.zoneFiles.length);
17 |     i = 0;
18 |     sampleTz = timezoneJS.timezone.getTzInfo(new Date(), 'Asia/Bangkok');
19 |     expect(sampleTz).toBeDefined();
20 |     expect(sampleTz.tzAbbr).toEqual('ICT');
21 |     expect(new timezoneJS.Date('America/New_York').getTimezoneOffset() > 0).toBe(true);
22 |   });
23 | });
24 | 


--------------------------------------------------------------------------------
/spec/tz.sync.spec.js:
--------------------------------------------------------------------------------
  1 | var TestUtils = require('./test-utils')
  2 |   , parseISO = TestUtils.parseISO
  3 |   , timezoneJS = TestUtils.getTimezoneJS();
  4 | describe('TimezoneJS', function () {
  5 |   it('should get America/Chicago DST time correctly', function () {
  6 |     var testDstLeap = function (arr) {
  7 |       var expectedArr = [360, 300, 300, 360];
  8 |       var dt;
  9 |       var actual;
 10 |       var expected;
 11 |       for (var i = 0; i < arr.length; i++) {
 12 |         dt = timezoneJS.timezone.getTzInfo(parseISO(arr[i]), 'America/Chicago');
 13 |         actual = dt.tzOffset;
 14 |         expected = expectedArr[i];
 15 |         expect(actual).toEqual(expected);
 16 |       }
 17 |     };
 18 |     testDstLeap(['2004-04-04', '2004-04-05', '2004-10-31', '2004-11-01']);
 19 |     testDstLeap(['2005-04-03', '2005-04-04', '2005-10-30', '2005-10-31']);
 20 |     testDstLeap(['2006-04-02', '2006-04-03', '2006-10-29', '2006-10-30']);
 21 |     // 2007 -- new DST rules start here
 22 |     testDstLeap(['2007-03-11', '2007-03-12', '2007-11-04', '2007-11-05']);
 23 |     testDstLeap(['2008-03-09', '2008-03-10', '2008-11-02', '2008-11-03']);
 24 |     testDstLeap(['2009-03-08', '2009-03-09', '2009-11-01', '2009-11-02']);
 25 |     testDstLeap(['2010-03-14', '2010-03-15', '2010-11-07', '2010-11-08']);
 26 |     testDstLeap(['2011-03-13', '2011-03-14', '2011-11-06', '2011-11-07']);
 27 |   });
 28 | 
 29 |   it('should get tzOffset of America/Sao_Paulo correctly', function () {
 30 |     // Source: http://www.timeanddate.com/worldclock/clockchange.html?n=233
 31 |     // Standard: GMT-3 from Feb 16 - Nov 1
 32 |     // Daylight: GMT-2 from Nov 2 - Feb 16
 33 |     var dt;
 34 |     // 2008
 35 |     //dt = timezoneJS.timezone.getTzInfo(parseISO('2008-02-16-02:00'), 'America/Sao_Paulo');
 36 |     //expect(120, dt.tzOffset);
 37 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2008-02-17'), 'America/Sao_Paulo');
 38 |     expect(dt.tzOffset).toEqual(180);
 39 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2008-10-11'), 'America/Sao_Paulo');
 40 |     expect(dt.tzOffset).toEqual(180);
 41 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2008-10-19'), 'America/Sao_Paulo');
 42 |     expect(dt.tzOffset).toEqual(120);
 43 |   });
 44 | 
 45 |   it('should get New_York time correctly', function () {
 46 |     // Source: http://www.timeanddate.com/worldclock/city.html?n=179
 47 |     // Changes every year!
 48 |     var dt;
 49 |     // 2006
 50 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2006-04-02T01:59:59'), 'America/New_York');
 51 |     expect(dt.tzOffset).toEqual(300);
 52 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2006-04-02T03:00:01'), 'America/New_York');
 53 |     expect(dt.tzOffset).toEqual(240);
 54 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2006-10-29T00:59:59'), 'America/New_York');
 55 |     expect(dt.tzOffset).toEqual(240);
 56 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2006-10-29T03:00:01'), 'America/New_York');
 57 |     expect(dt.tzOffset).toEqual(300);
 58 |     // 2009
 59 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2009-03-08T01:59:59'), 'America/New_York');
 60 |     expect(dt.tzOffset).toEqual(300);
 61 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2009-03-08T03:00:01'), 'America/New_York');
 62 |     expect(dt.tzOffset).toEqual(240);
 63 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2009-11-01T00:59:59'), 'America/New_York');
 64 |     expect(dt.tzOffset).toEqual(240);
 65 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2009-11-01T03:00:01'), 'America/New_York');
 66 |     expect(dt.tzOffset).toEqual(300);
 67 |   });
 68 | 
 69 |   it('should get Jerusalem time correctly', function () {
 70 |     // Source: http://www.timeanddate.com/worldclock/city.html?n=110
 71 |     // Changes every year!
 72 |     var dt;
 73 |     // 2008
 74 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2008-03-28T01:59:59'), 'Asia/Jerusalem');
 75 |     expect(dt.tzOffset).toEqual(-120);
 76 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2008-03-28T03:00:01'), 'Asia/Jerusalem');
 77 |     expect(dt.tzOffset).toEqual(-180);
 78 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2008-10-05T00:59:59'), 'Asia/Jerusalem');
 79 |     expect(dt.tzOffset).toEqual(-180);
 80 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2008-10-05T03:00:01'), 'Asia/Jerusalem');
 81 |     expect(dt.tzOffset).toEqual(-120);
 82 |     // 2009
 83 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2009-03-27T01:59:59'), 'Asia/Jerusalem');
 84 |     expect(dt.tzOffset).toEqual(-120);
 85 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2009-03-27T03:00:01'), 'Asia/Jerusalem');
 86 |     expect(dt.tzOffset).toEqual(-180);
 87 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2009-09-27T00:59:59'), 'Asia/Jerusalem');
 88 |     expect(dt.tzOffset).toEqual(-180);
 89 |     dt = timezoneJS.timezone.getTzInfo(parseISO('2009-09-27T03:00:01'), 'Asia/Jerusalem');
 90 |     expect(dt.tzOffset).toEqual(-120);
 91 |   });
 92 | 
 93 |   it('should get abbreviation of central EU time correctly', function () {
 94 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-01-01'), 'Europe/Berlin'); // winter time (CET) for sure
 95 |     expect(dt.tzAbbr).toEqual('CET');
 96 |   });
 97 | 
 98 |   it('should get abbr for central EU summer time correctly', function () {
 99 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-07-01'), 'Europe/Berlin'); // summer time (CEST) for sure
100 |     expect(dt.tzAbbr, 'CEST');
101 |   });
102 | 
103 |   it('should get abbr for British Standard time correctly', function () {
104 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-01-01'), 'Europe/London'); // winter time (GMT) for sure
105 |     expect(dt.tzAbbr, 'GMT');
106 |   });
107 | 
108 |   it('should get abbr for British summer time correctly', function () {
109 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-07-01'), 'Europe/London'); // summer time (BST) for sure
110 |     expect(dt.tzAbbr, 'BST');
111 |   });
112 | 
113 |   it('should get abbr CET from tz info of 2010-03-28T01:59:59', function () {
114 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-03-28T01:59:59'), 'Europe/Berlin'); // CET, from local time
115 |     expect(dt.tzAbbr).toEqual('CET');
116 |   });
117 | 
118 |   it('should get abbr CEST from tz info of 2010-03-08T03:00:00', function () {
119 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-03-28T03:00:00'), 'Europe/Berlin'); // CEST, from local time
120 |     expect(dt.tzAbbr, 'CEST');
121 |   });
122 | 
123 |   it('should get abbr CET from tz info of 2010-03-08T00:59:59 UTC', function () {
124 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-03-28T00:59:59'), 'Europe/Berlin', true); // CEST, from local time
125 |     expect(dt.tzAbbr, 'CET');
126 |   });
127 | 
128 |   it('should get abbr CEST from tz info of 2010-03-08T01:00:00 UTC', function () {
129 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-03-28T01:00:00'), 'Europe/Berlin', true); // CEST, from local time
130 |     expect(dt.tzAbbr, 'CEST');
131 |   });
132 | 
133 |   it('should get abbr CST from 2010-03-14T01:59:59 Chicago', function () {
134 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-03-14T01:59:59'), 'America/Chicago'); // CST, from local time
135 |     expect(dt.tzAbbr).toEqual('CST');
136 |   });
137 | 
138 |   it('should get abbr CDT from 2010-03-14T03:00:00 Chicago', function () {
139 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-03-14T03:00:00'), 'America/Chicago'); // CST, from local time
140 |     expect(dt.tzAbbr).toEqual('CDT');
141 |   });
142 | 
143 |   it('should get abbr CST from 2010-03-14T07:59:59 UTC', function () {
144 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-03-14T07:59:59'), 'America/Chicago', true); // CST, from local time
145 |     expect(dt.tzAbbr).toEqual('CST');
146 |   });
147 | 
148 |   it('should get abbr CDT from 2010-03-14T08:00:00 Chicago', function () {
149 |     var dt = timezoneJS.timezone.getTzInfo(parseISO('2010-03-14T08:00:00'), 'America/Chicago', true); // CST, from local time
150 |     expect(dt.tzAbbr).toEqual('CDT');
151 |   });
152 | 
153 |   it('should get correct region for tz', function () {
154 |     var t = timezoneJS.timezone.getRegionForTimezone('Africa/Abidjan');
155 |     expect(t).toEqual('africa');
156 |   });
157 | 
158 |   it('should get both northamerica and southamerica region for America', function () {
159 |     var t = timezoneJS.timezone.getRegionForTimezone('America/New_York');
160 |     expect(t).toEqual(['northamerica', 'southamerica']);
161 |   });
162 | 
163 |   //This is for issue #1 in github
164 |   it('should not get null in getAllZones', function () {
165 |     var zones = timezoneJS.timezone.getAllZones();
166 |     for (var i = 0; i < zones; i++) {
167 |       expect(zones[i]).not.toBe(null);
168 |     }
169 |   });
170 | 
171 |   it('should throw error with invalid zone', function () {
172 |     var testFn = function () {
173 |       timezoneJS.timezone.getTzInfo(new Date(), 'asd')
174 |     }
175 |     expect(testFn).toThrow(new Error('Timezone \'asd\' is either incorrect, or not loaded in the timezone registry.'));
176 |   });
177 | 
178 | });
179 | 


--------------------------------------------------------------------------------
/src/date.js:
--------------------------------------------------------------------------------
   1 | // -----
   2 | // The `timezoneJS.Date` object gives you full-blown timezone support, independent from the timezone set on the end-user's machine running the browser. It uses the Olson zoneinfo files for its timezone data.
   3 | //
   4 | // The constructor function and setter methods use proxy JavaScript Date objects behind the scenes, so you can use strings like '10/22/2006' with the constructor. You also get the same sensible wraparound behavior with numeric parameters (like setting a value of 14 for the month wraps around to the next March).
   5 | //
   6 | // The other significant difference from the built-in JavaScript Date is that `timezoneJS.Date` also has named properties that store the values of year, month, date, etc., so it can be directly serialized to JSON and used for data transfer.
   7 | 
   8 | /*
   9 |  * Copyright 2010 Matthew Eernisse (mde@fleegix.org)
  10 |  * and Open Source Applications Foundation
  11 |  *
  12 |  * Licensed under the Apache License, Version 2.0 (the 'License');
  13 |  * you may not use this file except in compliance with the License.
  14 |  * You may obtain a copy of the License at
  15 |  *
  16 |  *   http://www.apache.org/licenses/LICENSE-2.0
  17 |  *
  18 |  * Unless required by applicable law or agreed to in writing, software
  19 |  * distributed under the License is distributed on an 'AS IS' BASIS,
  20 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  21 |  * See the License for the specific language governing permissions and
  22 |  * limitations under the License.
  23 |  *
  24 |  * Credits: Ideas included from incomplete JS implementation of Olson
  25 |  * parser, 'XMLDAte' by Philippe Goetz (philippe.goetz@wanadoo.fr)
  26 |  *
  27 |  * Contributions:
  28 |  * Jan Niehusmann
  29 |  * Ricky Romero
  30 |  * Preston Hunt (prestonhunt@gmail.com)
  31 |  * Dov. B Katz (dov.katz@morganstanley.com)
  32 |  * Peter Bergström (pbergstr@mac.com)
  33 |  * Long Ho
  34 |  */
  35 | 
  36 |  /*jshint laxcomma:true, laxbreak:true, expr:true*/
  37 | (function () {
  38 |   // Standard initialization stuff to make sure the library is
  39 |   // usable on both client and server (node) side.
  40 |   'use strict';
  41 |   var root = this;
  42 | 
  43 |   // Export the timezoneJS object for Node.js, with backwards-compatibility for the old `require()` API
  44 |   var timezoneJS = {};
  45 |   if (typeof define === 'function' && define.amd) { // AMD
  46 |     define(function() {
  47 |      return timezoneJS;
  48 |     });
  49 |   } else if (typeof exports !== 'undefined') {
  50 |     if (typeof module !== 'undefined' && module.exports) {
  51 |       exports = module.exports = timezoneJS;
  52 |     }
  53 |     exports.timezoneJS = timezoneJS;
  54 |   } else {
  55 |     root.timezoneJS = timezoneJS;
  56 |   }
  57 | 
  58 |   timezoneJS.VERSION = '0.4.11';
  59 | 
  60 |   // Grab the ajax library from global context.
  61 |   // This can be jQuery, Zepto or fleegix.
  62 |   // You can also specify your own transport mechanism by declaring
  63 |   // `timezoneJS.timezone.transport` to a `function`. More details will follow
  64 |   var ajax_lib = root.jQuery || root.$ || root.Zepto
  65 |     , fleegix = root.fleegix
  66 |     // Declare constant list of days and months. Unfortunately this doesn't leave room for i18n due to the Olson data being in English itself
  67 |     , DAYS = timezoneJS.Days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
  68 |     , MONTHS = timezoneJS.Months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
  69 |     , SHORT_MONTHS = {}
  70 |     , SHORT_DAYS = {}
  71 |     , EXACT_DATE_TIME = {};
  72 | 
  73 |   //`{ 'Jan': 0, 'Feb': 1, 'Mar': 2, 'Apr': 3, 'May': 4, 'Jun': 5, 'Jul': 6, 'Aug': 7, 'Sep': 8, 'Oct': 9, 'Nov': 10, 'Dec': 11 }`
  74 |   for (var i = 0; i < MONTHS.length; i++) {
  75 |     SHORT_MONTHS[MONTHS[i].substr(0, 3)] = i;
  76 |   }
  77 | 
  78 |   //`{ 'Sun': 0, 'Mon': 1, 'Tue': 2, 'Wed': 3, 'Thu': 4, 'Fri': 5, 'Sat': 6 }`
  79 |   for (i = 0; i < DAYS.length; i++) {
  80 |     SHORT_DAYS[DAYS[i].substr(0, 3)] = i;
  81 |   }
  82 | 
  83 | 
  84 |   //Handle array indexOf in IE
  85 |   //From https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf
  86 |   //Extending Array prototype causes IE to iterate thru extra element
  87 |   var _arrIndexOf = Array.prototype.indexOf || function (el) {
  88 |     if (this === null) {
  89 |       throw new TypeError();
  90 |     }
  91 |     var t = Object(this);
  92 |     var len = t.length >>> 0;
  93 |     if (len === 0) {
  94 |       return -1;
  95 |     }
  96 |     var n = 0;
  97 |     if (arguments.length > 1) {
  98 |       n = Number(arguments[1]);
  99 |       if (n != n) { // shortcut for verifying if it's NaN
 100 |         n = 0;
 101 |       } else if (n !== 0 && n !== Infinity && n !== -Infinity) {
 102 |         n = (n > 0 || -1) * Math.floor(Math.abs(n));
 103 |       }
 104 |     }
 105 |     if (n >= len) {
 106 |       return -1;
 107 |     }
 108 |     var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
 109 |     for (; k < len; k++) {
 110 |       if (k in t && t[k] === el) {
 111 |         return k;
 112 |       }
 113 |     }
 114 |     return -1;
 115 |   };
 116 | 
 117 |   // Format a number to the length = digits. For ex:
 118 |   //
 119 |   // `_fixWidth(2, 2) = '02'`
 120 |   //
 121 |   // `_fixWidth(1998, 2) = '98'`  // year, shorten it to the 2 digit representation
 122 |   //
 123 |   // `_fixWidth(23, 1) = '23'`  // hour, even with 1 digit specified, do not trim
 124 |   //
 125 |   // This is used to pad numbers in converting date to string in ISO standard.
 126 |   var _fixWidth = function (number, digits) {
 127 |     if (typeof number !== 'number') { throw 'not a number: ' + number; }
 128 |     var trim = (number > 1000);   // only trim 'year', as the others don't make sense why anyone would want that
 129 |     var s = number.toString();
 130 |     var s_len = s.length;
 131 |     if (trim && s_len > digits) {
 132 |       return s.substr(s_len - digits, s_len);
 133 |     }
 134 |     s = [s];
 135 |     while (s_len < digits) {
 136 |       s.unshift('0');
 137 |       s_len++;
 138 |     }
 139 |     return s.join('');
 140 |   };
 141 | 
 142 |   // Abstraction layer for different transport layers, including fleegix/jQuery/Zepto/Node.js
 143 |   //
 144 |   // Object `opts` include
 145 |   //
 146 |   // - `url`: url to ajax query
 147 |   //
 148 |   // - `async`: true for asynchronous, false otherwise. If false, return value will be response from URL. This is true by default
 149 |   //
 150 |   // - `success`: success callback function
 151 |   //
 152 |   // - `error`: error callback function
 153 |   // Returns response from URL if async is false, otherwise the AJAX request object itself
 154 |   var _transport = function (opts) {
 155 |     if (!opts) return;
 156 |     if (!opts.url) throw new Error ('URL must be specified');
 157 |     if (!('async' in opts)) opts.async = true;
 158 | 
 159 |     // Server-side (node)
 160 |     // if node, require the file system module
 161 |     if (typeof window === 'undefined' && typeof require === 'function') {
 162 |       var nodefs = require('fs');
 163 |       if (opts.async) {
 164 |         // No point if there's no success handler
 165 |         if (typeof opts.success !== 'function') return;
 166 |         opts.error = opts.error || console.error;
 167 |         return nodefs.readFile(opts.url, 'utf8', function(err, data) {
 168 |           return err ? opts.error(err) : opts.success(data);
 169 |         });
 170 |       }
 171 |       return nodefs.readFileSync(opts.url, 'utf8');
 172 |     }
 173 | 
 174 |     // Client-side
 175 |     if ((!fleegix || typeof fleegix.xhr === 'undefined') && (!ajax_lib || typeof ajax_lib.ajax === 'undefined')) {
 176 |       throw new Error('Please use the Fleegix.js XHR module, jQuery ajax, Zepto ajax, or define your own transport mechanism for downloading zone files.');
 177 |     }
 178 |     if (!opts.async) {
 179 |       return fleegix && fleegix.xhr
 180 |       ? fleegix.xhr.doReq({ url: opts.url, async: false })
 181 |       : ajax_lib.ajax({ url : opts.url, async : false, dataType: 'text' }).responseText;
 182 |     }
 183 |     return fleegix && fleegix.xhr
 184 |     ? fleegix.xhr.send({
 185 |       url : opts.url,
 186 |       method : 'get',
 187 |       handleSuccess : opts.success,
 188 |       handleErr : opts.error
 189 |     })
 190 |     : ajax_lib.ajax({
 191 |       url : opts.url,
 192 |       dataType: 'text',
 193 |       method : 'GET',
 194 |       error : opts.error,
 195 |       success : opts.success
 196 |     });
 197 |   };
 198 | 
 199 |   // Constructor, which is similar to that of the native Date object itself
 200 |   timezoneJS.Date = function () {
 201 |     if(this === timezoneJS) {
 202 |       throw 'timezoneJS.Date object must be constructed with \'new\'';
 203 |     }
 204 |     var args = Array.prototype.slice.apply(arguments)
 205 |     , dt = null
 206 |     , tz = null
 207 |     , arr = []
 208 |     , valid = false
 209 |     ;
 210 | 
 211 | 
 212 |     //We support several different constructors, including all the ones from `Date` object
 213 |     // with a timezone string at the end.
 214 |     //
 215 |     //- `[tz]`: Returns object with time in `tz` specified.
 216 |     //
 217 |     // - `utcMillis`, `[tz]`: Return object with UTC time = `utcMillis`, in `tz`.
 218 |     //
 219 |     // - `Date`, `[tz]`: Returns object with UTC time = `Date.getTime()`, in `tz`.
 220 |     //
 221 |     // - `year, month, [date,] [hours,] [minutes,] [seconds,] [millis,] [tz]: Same as `Date` object
 222 |     // with tz.
 223 |     //
 224 |     // - `Array`: Can be any combo of the above.
 225 |     //
 226 |     //If 1st argument is an array, we can use it as a list of arguments itself
 227 |     if (Object.prototype.toString.call(args[0]) === '[object Array]') {
 228 |       args = args[0];
 229 |     }
 230 |     // If the last string argument doesn't parse as a Date, treat it as tz
 231 |     if (typeof args[args.length - 1] === 'string') {
 232 |       valid = Date.parse(args[args.length - 1].replace(/GMT[\+\-]\d+/, ''));
 233 |       if (isNaN(valid) || valid === null) {  // Checking against null is required for compatability with Datejs
 234 |         tz = args.pop();
 235 |       }
 236 |     }
 237 |     var is_dt_local = false;
 238 |     switch (args.length) {
 239 |       case 0:
 240 |         dt = new Date();
 241 |         break;
 242 |       case 1:
 243 |         dt = new Date(args[0]);
 244 |         // Date strings are local if they do not contain 'Z', 'T' or timezone offsets like '+0200'
 245 |         //  - more info below
 246 |         if (typeof args[0] == 'string' && args[0].search(/[+-][0-9]{4}/) == -1
 247 |                 && args[0].search(/Z/) == -1 && args[0].search(/T/) == -1) {
 248 |             is_dt_local = true;
 249 |         }
 250 |         break;
 251 |       case 2:
 252 |         dt = new Date(args[0], args[1]);
 253 |         is_dt_local = true;
 254 |         break;
 255 |       default:
 256 |         for (var i = 0; i < 7; i++) {
 257 |           arr[i] = args[i] || 0;
 258 |         }
 259 |         dt = new Date(arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6]);
 260 |         is_dt_local = true;
 261 |         break;
 262 |     }
 263 | 
 264 |     if (isNaN(dt.getTime())) { // invalid date were passed
 265 |       throw new Error('Invalid date');
 266 |     }
 267 | 
 268 |     this._useCache = false;
 269 |     this._tzInfo = {};
 270 |     this._day = 0;
 271 |     this.year = 0;
 272 |     this.month = 0;
 273 |     this.date = 0;
 274 |     this.hours = 0;
 275 |     this.minutes = 0;
 276 |     this.seconds = 0;
 277 |     this.milliseconds = 0;
 278 |     this.timezone = tz || null;
 279 |     // Tricky part:
 280 |     // The date is either given as unambiguous UTC date or otherwise the date is assumed
 281 |     // to be a date in timezone `tz` or a locale date if `tz` is not provided. Thus, to
 282 |     // determine how to use `dt` we distinguish between the following cases:
 283 |     //  - UTC   (is_dt_local = false)
 284 |     //    `timezoneJS.Date(millis, [tz])`
 285 |     //    `timezoneJS.Date(Date, [tz])`
 286 |     //    `timezoneJS.Date(dt_str_tz, [tz])`
 287 |     //  - local/timezone `tz`   (is_dt_local = true)
 288 |     //    `timezoneJS.Date(year, mon, day, [hour], [min], [second], [tz])`
 289 |     //    `timezoneJS.Date(dt_str, [tz])`
 290 |     //
 291 |     // `dt_str_tz` is a date string containing timezone information, i.e. containing 'Z', 'T' or
 292 |     // /[+-][0-9]{4}/ (e.g. '+0200'), while `dt_str` is a string which does not contain
 293 |     // timezone information. See: http://dygraphs.com/date-formats.html
 294 |     if (is_dt_local) {
 295 |        this.setFromDateObjProxy(dt);
 296 |     } else {
 297 |        this.setFromTimeProxy(dt.getTime(), tz);
 298 |     }
 299 |   };
 300 | 
 301 |   // Implements most of the native Date object
 302 |   timezoneJS.Date.prototype = {
 303 |     getDate: function () { return this.date; },
 304 |     getDay: function () { return this._day; },
 305 |     getFullYear: function () { return this.year; },
 306 |     getMonth: function () { return this.month; },
 307 |     getYear: function () { return this.year - 1900; },
 308 |     getHours: function () { return this.hours; },
 309 |     getMilliseconds: function () { return this.milliseconds; },
 310 |     getMinutes: function () { return this.minutes; },
 311 |     getSeconds: function () { return this.seconds; },
 312 |     getUTCDate: function () { return this.getUTCDateProxy().getUTCDate(); },
 313 |     getUTCDay: function () { return this.getUTCDateProxy().getUTCDay(); },
 314 |     getUTCFullYear: function () { return this.getUTCDateProxy().getUTCFullYear(); },
 315 |     getUTCHours: function () { return this.getUTCDateProxy().getUTCHours(); },
 316 |     getUTCMilliseconds: function () { return this.getUTCDateProxy().getUTCMilliseconds(); },
 317 |     getUTCMinutes: function () { return this.getUTCDateProxy().getUTCMinutes(); },
 318 |     getUTCMonth: function () { return this.getUTCDateProxy().getUTCMonth(); },
 319 |     getUTCSeconds: function () { return this.getUTCDateProxy().getUTCSeconds(); },
 320 |     // Time adjusted to user-specified timezone
 321 |     getTime: function () {
 322 |       return this._timeProxy + (this.getTimezoneOffset() * 60 * 1000);
 323 |     },
 324 |     getTimezone: function () { return this.timezone; },
 325 |     getTimezoneOffset: function () { return this.getTimezoneInfo().tzOffset; },
 326 |     getTimezoneAbbreviation: function () { return this.getTimezoneInfo().tzAbbr; },
 327 |     getTimezoneInfo: function () {
 328 |       if (this._useCache) return this._tzInfo;
 329 |       var res;
 330 |       // If timezone is specified, get the correct timezone info based on the Date given
 331 |       if (this.timezone) {
 332 |         res = this.timezone === 'Etc/UTC' || this.timezone === 'Etc/GMT'
 333 |           ? { tzOffset: 0, tzAbbr: 'UTC' }
 334 |           : timezoneJS.timezone.getTzInfo(this._timeProxy, this.timezone);
 335 |       }
 336 |       // If no timezone was specified, use the local browser offset
 337 |       else {
 338 |         res = { tzOffset: this.getLocalOffset(), tzAbbr: null };
 339 |       }
 340 |       this._tzInfo = res;
 341 |       this._useCache = true;
 342 |       return res;
 343 |     },
 344 |     getUTCDateProxy: function () {
 345 |       var dt = new Date(this._timeProxy);
 346 |       dt.setUTCMinutes(dt.getUTCMinutes() + this.getTimezoneOffset());
 347 |       return dt;
 348 |     },
 349 |     setDate: function (date) {
 350 |       this.setAttribute('date', date);
 351 |       return this.getTime();
 352 |     },
 353 |     setFullYear: function (year, month, date) {
 354 |       if (date !== undefined) { this.setAttribute('date', 1); }
 355 |       this.setAttribute('year', year);
 356 |       if (month !== undefined) { this.setAttribute('month', month); }
 357 |       if (date !== undefined) { this.setAttribute('date', date); }
 358 |       return this.getTime();
 359 |     },
 360 |     setMonth: function (month, date) {
 361 |       this.setAttribute('month', month);
 362 |       if (date !== undefined) { this.setAttribute('date', date); }
 363 |       return this.getTime();
 364 |     },
 365 |     setYear: function (year) {
 366 |       year = Number(year);
 367 |       if (0 <= year && year <= 99) { year += 1900; }
 368 |       this.setUTCAttribute('year', year);
 369 |       return this.getTime();
 370 |     },
 371 |     setHours: function (hours, minutes, seconds, milliseconds) {
 372 |       this.setAttribute('hours', hours);
 373 |       if (minutes !== undefined) { this.setAttribute('minutes', minutes); }
 374 |       if (seconds !== undefined) { this.setAttribute('seconds', seconds); }
 375 |       if (milliseconds !== undefined) { this.setAttribute('milliseconds', milliseconds); }
 376 |       return this.getTime();
 377 |     },
 378 |     setMinutes: function (minutes, seconds, milliseconds) {
 379 |       this.setAttribute('minutes', minutes);
 380 |       if (seconds !== undefined) { this.setAttribute('seconds', seconds); }
 381 |       if (milliseconds !== undefined) { this.setAttribute('milliseconds', milliseconds); }
 382 |       return this.getTime();
 383 |     },
 384 |     setSeconds: function (seconds, milliseconds) {
 385 |       this.setAttribute('seconds', seconds);
 386 |       if (milliseconds !== undefined) { this.setAttribute('milliseconds', milliseconds); }
 387 |       return this.getTime();
 388 |     },
 389 |     setMilliseconds: function (milliseconds) {
 390 |       this.setAttribute('milliseconds', milliseconds);
 391 |       return this.getTime();
 392 |     },
 393 |     setTime: function (n) {
 394 |       if (isNaN(n)) { throw new Error('Units must be a number.'); }
 395 |       this.setFromTimeProxy(n, this.timezone);
 396 |       return this.getTime();
 397 |     },
 398 |     setUTCFullYear: function (year, month, date) {
 399 |       if (date !== undefined) { this.setUTCAttribute('date', 1); }
 400 |       this.setUTCAttribute('year', year);
 401 |       if (month !== undefined) { this.setUTCAttribute('month', month); }
 402 |       if (date !== undefined) { this.setUTCAttribute('date', date); }
 403 |       return this.getTime();
 404 |     },
 405 |     setUTCMonth: function (month, date) {
 406 |       this.setUTCAttribute('month', month);
 407 |       if (date !== undefined) { this.setUTCAttribute('date', date); }
 408 |       return this.getTime();
 409 |     },
 410 |     setUTCDate: function (date) {
 411 |       this.setUTCAttribute('date', date);
 412 |       return this.getTime();
 413 |     },
 414 |     setUTCHours: function (hours, minutes, seconds, milliseconds) {
 415 |       this.setUTCAttribute('hours', hours);
 416 |       if (minutes !== undefined) { this.setUTCAttribute('minutes', minutes); }
 417 |       if (seconds !== undefined) { this.setUTCAttribute('seconds', seconds); }
 418 |       if (milliseconds !== undefined) { this.setUTCAttribute('milliseconds', milliseconds); }
 419 |       return this.getTime();
 420 |     },
 421 |     setUTCMinutes: function (minutes, seconds, milliseconds) {
 422 |       this.setUTCAttribute('minutes', minutes);
 423 |       if (seconds !== undefined) { this.setUTCAttribute('seconds', seconds); }
 424 |       if (milliseconds !== undefined) { this.setUTCAttribute('milliseconds', milliseconds); }
 425 |       return this.getTime();
 426 |     },
 427 |     setUTCSeconds: function (seconds, milliseconds) {
 428 |       this.setUTCAttribute('seconds', seconds);
 429 |       if (milliseconds !== undefined) { this.setUTCAttribute('milliseconds', milliseconds); }
 430 |       return this.getTime();
 431 |     },
 432 |     setUTCMilliseconds: function (milliseconds) {
 433 |       this.setUTCAttribute('milliseconds', milliseconds);
 434 |       return this.getTime();
 435 |     },
 436 |     setFromDateObjProxy: function (dt) {
 437 |       this.year = dt.getFullYear();
 438 |       this.month = dt.getMonth();
 439 |       this.date = dt.getDate();
 440 |       this.hours = dt.getHours();
 441 |       this.minutes = dt.getMinutes();
 442 |       this.seconds = dt.getSeconds();
 443 |       this.milliseconds = dt.getMilliseconds();
 444 |       this._day = dt.getDay();
 445 |       this._dateProxy = dt;
 446 |       this._timeProxy = Date.UTC(this.year, this.month, this.date, this.hours, this.minutes, this.seconds, this.milliseconds);
 447 |       this._useCache = false;
 448 |     },
 449 |     setFromTimeProxy: function (utcMillis, tz) {
 450 |       var dt = new Date(utcMillis);
 451 |       var tzOffset = tz ? timezoneJS.timezone.getTzInfo(utcMillis, tz, true).tzOffset : dt.getTimezoneOffset();
 452 |       dt.setTime(utcMillis + (dt.getTimezoneOffset() - tzOffset) * 60000);
 453 |       this.setFromDateObjProxy(dt);
 454 |     },
 455 |     setAttribute: function (unit, n) {
 456 |       if (isNaN(n)) { throw new Error('Units must be a number.'); }
 457 |       var dt = this._dateProxy;
 458 |       var meth = unit === 'year' ? 'FullYear' : unit.substr(0, 1).toUpperCase() + unit.substr(1);
 459 |       dt['set' + meth](n);
 460 |       this.setFromDateObjProxy(dt);
 461 |     },
 462 |     setUTCAttribute: function (unit, n) {
 463 |       if (isNaN(n)) { throw new Error('Units must be a number.'); }
 464 |       var meth = unit === 'year' ? 'FullYear' : unit.substr(0, 1).toUpperCase() + unit.substr(1);
 465 |       var dt = this.getUTCDateProxy();
 466 |       dt['setUTC' + meth](n);
 467 |       dt.setUTCMinutes(dt.getUTCMinutes() - this.getTimezoneOffset());
 468 |       this.setFromTimeProxy(dt.getTime() + this.getTimezoneOffset() * 60000, this.timezone);
 469 |     },
 470 |     setTimezone: function (tz) {
 471 |       var previousOffset = this.getTimezoneInfo().tzOffset;
 472 |       this.timezone = tz;
 473 |       this._useCache = false;
 474 |       // Set UTC minutes offsets by the delta of the two timezones
 475 |       this.setUTCMinutes(this.getUTCMinutes() - this.getTimezoneInfo().tzOffset + previousOffset);
 476 |     },
 477 |     removeTimezone: function () {
 478 |       this.timezone = null;
 479 |       this._useCache = false;
 480 |     },
 481 |     valueOf: function () { return this.getTime(); },
 482 |     clone: function () {
 483 |       return this.timezone ? new timezoneJS.Date(this.getTime(), this.timezone) : new timezoneJS.Date(this.getTime());
 484 |     },
 485 |     toGMTString: function () { return this.toString('EEE, dd MMM yyyy HH:mm:ss Z', 'Etc/GMT'); },
 486 |     toLocaleString: function () {},
 487 |     toLocaleDateString: function () {},
 488 |     toLocaleTimeString: function () {},
 489 |     toSource: function () {},
 490 |     toISOString: function () { return this.toString('yyyy-MM-ddTHH:mm:ss.SSS', 'Etc/UTC') + 'Z'; },
 491 |     toJSON: function () { return this.toISOString(); },
 492 |     toDateString: function () { return this.toString('EEE MMM dd yyyy'); },
 493 |     toTimeString: function () { return this.toString('H:mm k'); },
 494 |     // Allows different format following ISO8601 format:
 495 |     toString: function (format, tz) {
 496 |       // Default format is the same as toISOString
 497 |       if (!format) format = 'yyyy-MM-ddTHH:mm:ss.SSS';
 498 |       var result = format;
 499 |       var tzInfo = tz ? timezoneJS.timezone.getTzInfo(this.getTime(), tz) : this.getTimezoneInfo();
 500 |       var _this = this;
 501 |       // If timezone is specified, get a clone of the current Date object and modify it
 502 |       if (tz) {
 503 |         _this = this.clone();
 504 |         _this.setTimezone(tz);
 505 |       }
 506 |       var hours = _this.getHours();
 507 |       return result
 508 |       // fix the same characters in Month names
 509 |       .replace(/a+/g, function () { return 'k'; })
 510 |       // `y`: year
 511 |       .replace(/y+/g, function (token) { return _fixWidth(_this.getFullYear(), token.length); })
 512 |       // `d`: date
 513 |       .replace(/d+/g, function (token) { return _fixWidth(_this.getDate(), token.length); })
 514 |       // `m`: minute
 515 |       .replace(/m+/g, function (token) { return _fixWidth(_this.getMinutes(), token.length); })
 516 |       // `s`: second
 517 |       .replace(/s+/g, function (token) { return _fixWidth(_this.getSeconds(), token.length); })
 518 |       // `S`: millisecond
 519 |       .replace(/S+/g, function (token) { return _fixWidth(_this.getMilliseconds(), token.length); })
 520 |       // 'h': 12 hour format
 521 |       .replace(/h+/g, function (token) { return _fixWidth( ((hours%12) === 0) ? 12 : (hours % 12), token.length); })
 522 |       // `M`: month. Note: `MM` will be the numeric representation (e.g February is 02) but `MMM` will be text representation (e.g February is Feb)
 523 |       .replace(/M+/g, function (token) {
 524 |         var _month = _this.getMonth(),
 525 |         _len = token.length;
 526 |         if (_len > 3) {
 527 |           return timezoneJS.Months[_month];
 528 |         } else if (_len > 2) {
 529 |           return timezoneJS.Months[_month].substring(0, _len);
 530 |         }
 531 |         return _fixWidth(_month + 1, _len);
 532 |       })
 533 |       // `k`: AM/PM
 534 |       .replace(/k+/g, function () {
 535 |         if (hours >= 12) {
 536 |           if (hours > 12) {
 537 |             hours -= 12;
 538 |           }
 539 |           return 'PM';
 540 |         }
 541 |         return 'AM';
 542 |       })
 543 |       // `H`: hour
 544 |       .replace(/H+/g, function (token) { return _fixWidth(hours, token.length); })
 545 |       // `E`: day
 546 |       .replace(/E+/g, function (token) { return DAYS[_this.getDay()].substring(0, token.length); })
 547 |       // `Z`: timezone abbreviation
 548 |       .replace(/Z+/gi, function () { return tzInfo.tzAbbr; });
 549 |     },
 550 |     toUTCString: function () { return this.toGMTString(); },
 551 |     civilToJulianDayNumber: function (y, m, d) {
 552 |       var a;
 553 |       // Adjust for zero-based JS-style array
 554 |       m++;
 555 |       if (m > 12) {
 556 |         a = parseInt(m/12, 10);
 557 |         m = m % 12;
 558 |         y += a;
 559 |       }
 560 |       if (m <= 2) {
 561 |         y -= 1;
 562 |         m += 12;
 563 |       }
 564 |       a = Math.floor(y / 100);
 565 |       var b = 2 - a + Math.floor(a / 4)
 566 |         , jDt = Math.floor(365.25 * (y + 4716)) + Math.floor(30.6001 * (m + 1)) + d + b - 1524;
 567 |       return jDt;
 568 |     },
 569 |     getLocalOffset: function () {
 570 |       return this._dateProxy.getTimezoneOffset();
 571 |     }
 572 |   };
 573 | 
 574 | 
 575 |   timezoneJS.timezone = new function () {
 576 |     var _this = this
 577 |       , regionMap = {'Etc':'etcetera','EST':'northamerica','MST':'northamerica','HST':'northamerica','EST5EDT':'northamerica','CST6CDT':'northamerica','MST7MDT':'northamerica','PST8PDT':'northamerica','America':['northamerica','southamerica'],'Pacific':'australasia','Atlantic':'europe','Africa':'africa','Indian':'africa','Antarctica':'antarctica','Asia':'asia','Australia':'australasia','Europe':'europe','WET':'europe','CET':'europe','MET':'europe','EET':'europe'}
 578 |       , regionExceptions = {'Pacific/Honolulu':'northamerica','Atlantic/Bermuda':'northamerica','Atlantic/Cape_Verde':'africa','Atlantic/St_Helena':'africa','Indian/Kerguelen':'antarctica','Indian/Chagos':'asia','Indian/Maldives':'asia','Indian/Christmas':'australasia','Indian/Cocos':'australasia','America/Danmarkshavn':'europe','America/Scoresbysund':'europe','America/Godthab':'europe','America/Thule':'europe','Asia/Istanbul':'europe','Asia/Yekaterinburg':'europe','Asia/Omsk':'europe','Asia/Novosibirsk':'europe','Asia/Krasnoyarsk':'europe','Asia/Irkutsk':'europe','Asia/Yakutsk':'europe','Asia/Vladivostok':'europe','Asia/Sakhalin':'europe','Asia/Magadan':'europe','Asia/Kamchatka':'europe','Asia/Anadyr':'europe','Africa/Ceuta':'europe','GMT':'etcetera','Europe/Nicosia':'asia'};
 579 |     function invalidTZError(t) { throw new Error('Timezone \'' + t + '\' is either incorrect, or not loaded in the timezone registry.'); }
 580 |     function builtInLoadZoneFile(fileName, opts) {
 581 |       var url = _this.zoneFileBasePath + '/' + fileName;
 582 |       return !opts || !opts.async
 583 |       ? _this.parseZones(_this.transport({ url : url, async : false }))
 584 |       : _this.transport({
 585 |         async: true,
 586 |         url : url,
 587 |         success : function (str) {
 588 |           return _this.parseZones(str) && typeof opts.callback === 'function' && opts.callback();
 589 |         },
 590 |         error : function () {
 591 |           throw new Error('Error retrieving \'' + url + '\' zoneinfo files');
 592 |         }
 593 |       });
 594 |     }
 595 |     function getRegionForTimezone(tz) {
 596 |       var exc = regionExceptions[tz]
 597 |         , reg
 598 |         , ret;
 599 |       if (exc) return exc;
 600 |       reg = tz.split('/')[0];
 601 |       ret = regionMap[reg];
 602 |       // If there's nothing listed in the main regions for this TZ, check the 'backward' links
 603 |       if (ret) return ret;
 604 |       var link = _this.zones[tz];
 605 |       if (typeof link === 'string') {
 606 |         return getRegionForTimezone(link);
 607 |       }
 608 |       // Backward-compat file hasn't loaded yet, try looking in there
 609 |       if (!_this.loadedZones.backward) {
 610 |         // This is for obvious legacy zones (e.g., Iceland) that don't even have a prefix like 'America/' that look like normal zones
 611 |         _this.loadZoneFile('backward');
 612 |         return getRegionForTimezone(tz);
 613 |       }
 614 |       invalidTZError(tz);
 615 |     }
 616 |     //str has format hh:mm, can be negative
 617 |     function parseTimeString(str) {
 618 |       var pat = /(\d+)(?::0*(\d*))?(?::0*(\d*))?([wsugz])?$/;
 619 |       var hms = str.match(pat);
 620 |       hms[1] = parseInt(hms[1], 10);
 621 |       hms[2] = hms[2] ? parseInt(hms[2], 10) : 0;
 622 |       hms[3] = hms[3] ? parseInt(hms[3], 10) : 0;
 623 |       return hms.slice(1, 5);
 624 |     }
 625 |     //z is something like `[ '-3:44:40', '-', 'LMT', '1911', 'May', '15', '' ]` or `[ '-5:00', '-', 'EST', '1974', 'Apr', '28', '2:00' ]`
 626 |     function processZone(z) {
 627 |       if (!z[3]) { return; }
 628 |       var yea = parseInt(z[3], 10)
 629 |         , mon = 11
 630 |         , dat = 31;
 631 |       //If month is there
 632 |       if (z[4]) {
 633 |         mon = SHORT_MONTHS[z[4].substr(0, 3)];
 634 |         dat = parseInt(z[5], 10) || 1;
 635 |       }
 636 |       var t = z[6] ? parseTimeString(z[6]) : [0, 0, 0];
 637 |       return [yea, mon, dat, t[0], t[1], t[2]];
 638 |     }
 639 |     function getZone(dt, tz) {
 640 |       var utcMillis = typeof dt === 'number' ? dt : new Date(dt).getTime();
 641 |       var t = tz;
 642 |       var zoneList = _this.zones[t];
 643 |       // Follow links to get to an actual zone
 644 |       while (typeof zoneList === 'string') {
 645 |         t = zoneList;
 646 |         zoneList = _this.zones[t];
 647 |       }
 648 |       if (!zoneList) {
 649 |         // Backward-compat file hasn't loaded yet, try looking in there
 650 |         if (!_this.loadedZones.backward) {
 651 |           //This is for backward entries like 'America/Fort_Wayne' that
 652 |           // getRegionForTimezone *thinks* it has a region file and zone
 653 |           // for (e.g., America => 'northamerica'), but in reality it's a
 654 |           // legacy zone we need the backward file for.
 655 |           _this.loadZoneFile('backward');
 656 |           return getZone(dt, tz);
 657 |         } else if (t && t !== tz) {
 658 |           //Load the linked zone found in the backward file
 659 |           _this.lazyLoadZoneFiles(t);
 660 |           return getZone(dt, t);
 661 |         }
 662 |         invalidTZError(t);
 663 |       }
 664 |       if (zoneList.length === 0) {
 665 |         throw new Error('No Zone found for \'' + tz + '\' on ' + dt);
 666 |       }
 667 |       //Do backwards lookup since most use cases deal with newer dates.
 668 |       for (var i = zoneList.length - 1; i >= 0; i--) {
 669 |         var z = zoneList[i];
 670 |         if (z[3] && utcMillis > z[3]) break;
 671 |       }
 672 |       return zoneList[i+1];
 673 |     }
 674 |     function getBasicOffset(time) {
 675 |       var off = parseTimeString(time)
 676 |         , adj = time.charAt(0) === '-' ? -1 : 1;
 677 |       off = adj * (((off[0] * 60 + off[1]) * 60 + off[2]) * 1000);
 678 |       return off/60/1000;
 679 |     }
 680 |     function getAdjustedOffset(off, min) {
 681 |       return -Math.ceil(min - off);
 682 |     }
 683 | 
 684 |     //if isUTC is true, date is given in UTC, otherwise it's given
 685 |     // in local time (ie. date.getUTC*() returns local time components)
 686 |     function getRule(dt, zone, isUTC) {
 687 |       var date = typeof dt === 'number' ? new Date(dt) : dt;
 688 |       var ruleset = zone[1];
 689 |       var basicOffset = zone[0];
 690 | 
 691 |       // If the zone has a DST rule like '1:00', create a rule and return it
 692 |       // instead of looking it up in the parsed rules
 693 |       var staticDstMatch = ruleset.match(/^([0-9]):([0-9][0-9])$/);
 694 |       if (staticDstMatch) {
 695 |         return [-1000000, 'max', '-', 'Jan', 1, [0, 0, 0], parseInt(staticDstMatch[1],10) * 60 + parseInt(staticDstMatch[2], 10), '-'];
 696 |       }
 697 | 
 698 |       //Convert a date to UTC. Depending on the 'type' parameter, the date
 699 |       // parameter may be:
 700 |       //
 701 |       // - `u`, `g`, `z`: already UTC (no adjustment).
 702 |       //
 703 |       // - `s`: standard time (adjust for time zone offset but not for DST)
 704 |       //
 705 |       // - `w`: wall clock time (adjust for both time zone and DST offset).
 706 |       //
 707 |       // DST adjustment is done using the rule given as third argument.
 708 |       var convertDateToUTC = function (date, type, rule) {
 709 |         var offset = 0;
 710 | 
 711 |         if (type === 'u' || type === 'g' || type === 'z') { // UTC
 712 |           offset = 0;
 713 |         } else if (type === 's') { // Standard Time
 714 |           offset = basicOffset;
 715 |         } else if (type === 'w' || !type) { // Wall Clock Time
 716 |           offset = getAdjustedOffset(basicOffset, rule[6]);
 717 |         } else {
 718 |           throw new Error('unknown type ' + type);
 719 |         }
 720 |         offset *= 60 * 1000; // to millis
 721 | 
 722 |         return new Date(date.getTime() + offset);
 723 |       };
 724 | 
 725 |       //Step 1:  Find applicable rules for this year.
 726 |       //
 727 |       //Step 2:  Sort the rules by effective date.
 728 |       //
 729 |       //Step 3:  Check requested date to see if a rule has yet taken effect this year.  If not,
 730 |       //
 731 |       //Step 4:  Get the rules for the previous year.  If there isn't an applicable rule for last year, then
 732 |       // there probably is no current time offset since they seem to explicitly turn off the offset
 733 |       // when someone stops observing DST.
 734 |       //
 735 |       // FIXME if this is not the case and we'll walk all the way back (ugh).
 736 |       //
 737 |       //Step 5:  Sort the rules by effective date.
 738 |       //Step 6:  Apply the most recent rule before the current time.
 739 |       var convertRuleToExactDateAndTime = function (yearAndRule, prevRule) {
 740 |         var year = yearAndRule[0]
 741 |           , rule = yearAndRule[1];
 742 |           // Assume that the rule applies to the year of the given date.
 743 | 
 744 |         var hms = rule[5];
 745 |         var effectiveDate;
 746 | 
 747 |         if (!EXACT_DATE_TIME[year])
 748 |           EXACT_DATE_TIME[year] = {};
 749 | 
 750 |         // Result for given parameters is already stored
 751 |         if (EXACT_DATE_TIME[year][rule])
 752 |           effectiveDate = EXACT_DATE_TIME[year][rule];
 753 |         else {
 754 |           //If we have a specific date, use that!
 755 |           if (!isNaN(rule[4])) {
 756 |             effectiveDate = new Date(Date.UTC(year, SHORT_MONTHS[rule[3]], rule[4], hms[0], hms[1], hms[2], 0));
 757 |           }
 758 |           //Let's hunt for the date.
 759 |           else {
 760 |             var targetDay
 761 |               , operator;
 762 |             //Example: `lastThu`
 763 |             if (rule[4].substr(0, 4) === 'last') {
 764 |               // Start at the last day of the month and work backward.
 765 |               effectiveDate = new Date(Date.UTC(year, SHORT_MONTHS[rule[3]] + 1, 1, hms[0] - 24, hms[1], hms[2], 0));
 766 |               targetDay = SHORT_DAYS[rule[4].substr(4, 3)];
 767 |               operator = '<=';
 768 |             }
 769 |             //Example: `Sun>=15`
 770 |             else {
 771 |               //Start at the specified date.
 772 |               effectiveDate = new Date(Date.UTC(year, SHORT_MONTHS[rule[3]], rule[4].substr(5), hms[0], hms[1], hms[2], 0));
 773 |               targetDay = SHORT_DAYS[rule[4].substr(0, 3)];
 774 |               operator = rule[4].substr(3, 2);
 775 |             }
 776 |             var ourDay = effectiveDate.getUTCDay();
 777 |             //Go forwards.
 778 |             if (operator === '>=') {
 779 |               effectiveDate.setUTCDate(effectiveDate.getUTCDate() + (targetDay - ourDay + ((targetDay < ourDay) ? 7 : 0)));
 780 |             }
 781 |             //Go backwards.  Looking for the last of a certain day, or operator is '<=' (less likely).
 782 |             else {
 783 |               effectiveDate.setUTCDate(effectiveDate.getUTCDate() + (targetDay - ourDay - ((targetDay > ourDay) ? 7 : 0)));
 784 |             }
 785 |           }
 786 |           EXACT_DATE_TIME[year][rule] = effectiveDate;
 787 |         }
 788 | 
 789 | 
 790 |         //If previous rule is given, correct for the fact that the starting time of the current
 791 |         // rule may be specified in local time.
 792 |         if (prevRule) {
 793 |           effectiveDate = convertDateToUTC(effectiveDate, hms[3], prevRule);
 794 |         }
 795 |         return effectiveDate;
 796 |       };
 797 | 
 798 |       var findApplicableRules = function (year, ruleset) {
 799 |         var applicableRules = [];
 800 |         for (var i = 0; ruleset && i < ruleset.length; i++) {
 801 |           //Exclude future rules.
 802 |           if (ruleset[i][0] <= year &&
 803 |               (
 804 |                 // Date is in a set range.
 805 |                 ruleset[i][1] >= year ||
 806 |                 // Date is in an 'only' year.
 807 |                   (ruleset[i][0] === year && ruleset[i][1] === 'only') ||
 808 |                 //We're in a range from the start year to infinity.
 809 |                     ruleset[i][1] === 'max'
 810 |           )
 811 |              ) {
 812 |                //It's completely okay to have any number of matches here.
 813 |                // Normally we should only see two, but that doesn't preclude other numbers of matches.
 814 |                // These matches are applicable to this year.
 815 |                applicableRules.push([year, ruleset[i]]);
 816 |              }
 817 |         }
 818 |         return applicableRules;
 819 |       };
 820 | 
 821 |       var compareDates = function (a, b, prev) {
 822 |         var year, rule;
 823 |         if (!(a instanceof Date)) {
 824 |           year = a[0];
 825 |           rule = a[1];
 826 |           a = (!prev && EXACT_DATE_TIME[year] && EXACT_DATE_TIME[year][rule])
 827 |             ? EXACT_DATE_TIME[year][rule]
 828 |             : convertRuleToExactDateAndTime(a, prev);
 829 |         } else if (prev) {
 830 |           a = convertDateToUTC(a, isUTC ? 'u' : 'w', prev);
 831 |         }
 832 |         if (!(b instanceof Date)) {
 833 |           year = b[0];
 834 |           rule = b[1];
 835 |           b = (!prev && EXACT_DATE_TIME[year] && EXACT_DATE_TIME[year][rule]) ? EXACT_DATE_TIME[year][rule]
 836 |             : convertRuleToExactDateAndTime(b, prev);
 837 |         } else if (prev) {
 838 |           b = convertDateToUTC(b, isUTC ? 'u' : 'w', prev);
 839 |         }
 840 |         a = Number(a);
 841 |         b = Number(b);
 842 |         return a - b;
 843 |       };
 844 | 
 845 |       var year = date.getUTCFullYear();
 846 |       var applicableRules;
 847 | 
 848 |       applicableRules = findApplicableRules(year, _this.rules[ruleset]);
 849 |       applicableRules.push(date);
 850 |       //While sorting, the time zone in which the rule starting time is specified
 851 |       // is ignored. This is ok as long as the timespan between two DST changes is
 852 |       // larger than the DST offset, which is probably always true.
 853 |       // As the given date may indeed be close to a DST change, it may get sorted
 854 |       // to a wrong position (off by one), which is corrected below.
 855 |       applicableRules.sort(compareDates);
 856 | 
 857 |       //If there are not enough past DST rules...
 858 |       if (_arrIndexOf.call(applicableRules, date) < 2) {
 859 |         applicableRules = applicableRules.concat(findApplicableRules(year-1, _this.rules[ruleset]));
 860 |         applicableRules.sort(compareDates);
 861 |       }
 862 |       var pinpoint = _arrIndexOf.call(applicableRules, date);
 863 |       if (pinpoint > 1 && compareDates(date, applicableRules[pinpoint-1], applicableRules[pinpoint-2][1]) < 0) {
 864 |         //The previous rule does not really apply, take the one before that.
 865 |         return applicableRules[pinpoint - 2][1];
 866 |       } else if (pinpoint > 0 && pinpoint < applicableRules.length - 1 && compareDates(date, applicableRules[pinpoint+1], applicableRules[pinpoint-1][1]) > 0) {
 867 | 
 868 |         //The next rule does already apply, take that one.
 869 |         return applicableRules[pinpoint + 1][1];
 870 |       } else if (pinpoint === 0) {
 871 |         //No applicable rule found in this and in previous year.
 872 |         return null;
 873 |       }
 874 |       return applicableRules[pinpoint - 1][1];
 875 |     }
 876 |     function getAbbreviation(zone, rule) {
 877 |       var base = zone[2];
 878 |       if (base.indexOf('%s') > -1) {
 879 |         var repl;
 880 |         if (rule) {
 881 |           repl = rule[7] === '-' ? '' : rule[7];
 882 |         }
 883 |         //FIXME: Right now just falling back to Standard --
 884 |         // apparently ought to use the last valid rule,
 885 |         // although in practice that always ought to be Standard
 886 |         else {
 887 |           repl = 'S';
 888 |         }
 889 |         return base.replace('%s', repl);
 890 |       } else if (base.indexOf('/') > -1) {
 891 |         //Chose one of two alternative strings.
 892 |         return base.split('/', 2)[rule ? (rule[6] ? 1 : 0) : 0];
 893 |       }
 894 |       return base;
 895 |     }
 896 | 
 897 |     this.zoneFileBasePath = null;
 898 |     this.zoneFiles = ['africa', 'antarctica', 'asia', 'australasia', 'backward', 'etcetera', 'europe', 'northamerica', 'pacificnew', 'southamerica'];
 899 |     this.loadingSchemes = {
 900 |       PRELOAD_ALL: 'preloadAll',
 901 |       LAZY_LOAD: 'lazyLoad',
 902 |       MANUAL_LOAD: 'manualLoad'
 903 |     };
 904 |     this.getRegionForTimezone = getRegionForTimezone;
 905 |     this.loadingScheme = this.loadingSchemes.LAZY_LOAD;
 906 |     this.loadedZones = {};
 907 |     this.zones = {};
 908 |     this.rules = {};
 909 | 
 910 |     this.init = function (o) {
 911 |       var opts = { async: true }
 912 |         , def = this.loadingScheme === this.loadingSchemes.PRELOAD_ALL
 913 |           ? this.zoneFiles
 914 |           : (this.defaultZoneFile || 'northamerica');
 915 |       //Override default with any passed-in opts
 916 |       for (var p in o) {
 917 |         opts[p] = o[p];
 918 |       }
 919 |       return this.loadZoneFiles(def, opts);
 920 |     };
 921 | 
 922 |     //Get a single zone file, or all files in an array
 923 |     this.loadZoneFiles = function(fileNames, opts) {
 924 |       var callbackFn
 925 |         , done = 0;
 926 |       if (typeof fileNames === 'string') {
 927 |         return this.loadZoneFile(fileNames, opts);
 928 |       }
 929 |       //Wraps callback function in another one that makes
 930 |       // sure all files have been loaded.
 931 |       opts = opts || {};
 932 |       callbackFn = opts.callback;
 933 |       opts.callback = function () {
 934 |         done++;
 935 |         (done === fileNames.length) && typeof callbackFn === 'function' && callbackFn();
 936 |       };
 937 |       for (var i = 0; i < fileNames.length; i++) {
 938 |         this.loadZoneFile(fileNames[i], opts);
 939 |       }
 940 |     };
 941 |     //Get the zone files via XHR -- if the sync flag
 942 |     // is set to true, it's being called by the lazy-loading
 943 |     // mechanism, so the result needs to be returned inline.
 944 |     this.loadZoneFile = function (fileName, opts) {
 945 |       if (typeof this.zoneFileBasePath === 'undefined') {
 946 |         throw new Error('Please define a base path to your zone file directory -- timezoneJS.timezone.zoneFileBasePath.');
 947 |       }
 948 |       //Ignore already loaded zones.
 949 |       if (this.loadedZones[fileName]) {
 950 |         return;
 951 |       }
 952 |       this.loadedZones[fileName] = true;
 953 |       return builtInLoadZoneFile(fileName, opts);
 954 |     };
 955 |     this.loadZoneJSONData = function (url, sync) {
 956 |       var processData = function (data) {
 957 |         data = eval('('+ data +')');
 958 |         for (var z in data.zones) {
 959 |           _this.zones[z] = data.zones[z];
 960 |         }
 961 |         for (var r in data.rules) {
 962 |           _this.rules[r] = data.rules[r];
 963 |         }
 964 |       };
 965 |       return sync
 966 |       ? processData(_this.transport({ url : url, async : false }))
 967 |       : _this.transport({ url : url, success : processData });
 968 |     };
 969 |     this.loadZoneDataFromObject = function (data) {
 970 |       if (!data) { return; }
 971 |       for (var z in data.zones) {
 972 |         _this.zones[z] = data.zones[z];
 973 |       }
 974 |       for (var r in data.rules) {
 975 |         _this.rules[r] = data.rules[r];
 976 |       }
 977 |     };
 978 |     this.getAllZones = function () {
 979 |       var arr = [];
 980 |       for (var z in this.zones) { arr.push(z); }
 981 |       return arr.sort();
 982 |     };
 983 |     this.parseZones = function (str) {
 984 | 
 985 |       if (!str) {
 986 |         return false;
 987 |       }
 988 | 
 989 |       var lines = str.split('\n')
 990 |         , arr = []
 991 |         , chunk = ''
 992 |         , l
 993 |         , zone = null
 994 |         , rule = null;
 995 |       for (var i = 0; i < lines.length; i++) {
 996 |         l = lines[i];
 997 |         if (l.match(/^\s/)) {
 998 |           l = 'Zone ' + zone + l;
 999 |         }
1000 |         l = l.split('#')[0];
1001 |         if (l.length > 3) {
1002 |           arr = l.split(/\s+/);
1003 |           chunk = arr.shift();
1004 |           //Ignore Leap.
1005 |           switch (chunk) {
1006 |             case 'Zone':
1007 |               zone = arr.shift();
1008 |               if (!_this.zones[zone]) {
1009 |                 _this.zones[zone] = [];
1010 |               }
1011 |               if (arr.length < 3) break;
1012 |               //Process zone right here and replace 3rd element with the processed array.
1013 |               arr.splice(3, arr.length, processZone(arr));
1014 |               if (arr[3]) arr[3] = Date.UTC.apply(null, arr[3]);
1015 |               arr[0] = -getBasicOffset(arr[0]);
1016 |               _this.zones[zone].push(arr);
1017 |               break;
1018 |             case 'Rule':
1019 |               rule = arr.shift();
1020 |               if (!_this.rules[rule]) {
1021 |                 _this.rules[rule] = [];
1022 |               }
1023 |               //Parse int FROM year and TO year
1024 |               arr[0] = parseInt(arr[0], 10);
1025 |               arr[1] = parseInt(arr[1], 10) || arr[1];
1026 |               //Parse time string AT
1027 |               arr[5] = parseTimeString(arr[5]);
1028 |               //Parse offset SAVE
1029 |               arr[6] = getBasicOffset(arr[6]);
1030 |               _this.rules[rule].push(arr);
1031 |               break;
1032 |             case 'Link':
1033 |               //No zones for these should already exist.
1034 |               if (_this.zones[arr[1]]) {
1035 |                 throw new Error('Error with Link ' + arr[1] + '. Cannot create link of a preexisted zone.');
1036 |               }
1037 |               //Create the link.
1038 |               //Links are saved as strings that are the keys
1039 |               //of their referenced values.
1040 |               //Ex: "US/Central": "America/Chicago"
1041 |               if (isNaN(arr[0])) {
1042 |                 _this.zones[arr[1]] = arr[0];
1043 |               }
1044 |               else {
1045 |                 _this.zones[arr[1]] = parseInt(arr[0], 10);
1046 |               }
1047 |               break;
1048 |           }
1049 |         }
1050 |       }
1051 |       return true;
1052 |     };
1053 |     //Expose transport mechanism and allow overwrite.
1054 |     this.transport = _transport;
1055 |     this.getTzInfo = function (dt, tz, isUTC) {
1056 |       this.lazyLoadZoneFiles(tz);
1057 |       var z = getZone(dt, tz);
1058 |       var off = +z[0];
1059 |       //See if the offset needs adjustment.
1060 |       var rule = getRule(dt, z, isUTC);
1061 |       if (rule) {
1062 |         off = getAdjustedOffset(off, rule[6]);
1063 |       }
1064 |       var abbr = getAbbreviation(z, rule);
1065 |       return { tzOffset: off, tzAbbr: abbr };
1066 |     };
1067 |     //Lazy-load any zones not yet loaded.
1068 |     this.lazyLoadZoneFiles = function(tz) {
1069 |       if (this.loadingScheme === this.loadingSchemes.LAZY_LOAD) {
1070 |         //Get the correct region for the zone.
1071 |         var zoneFile = getRegionForTimezone(tz);
1072 |         if (!zoneFile) {
1073 |           throw new Error('Not a valid timezone ID.');
1074 |         }
1075 |         //Get the file and parse it -- use synchronous XHR.
1076 |         this.loadZoneFiles(zoneFile);
1077 |       }
1078 |     };
1079 |   }();
1080 | }).call(typeof window !== "undefined" ? window : this);
1081 | 


--------------------------------------------------------------------------------
/src/node-preparse.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var files = [ 'africa'
 3 | , 'antarctica'
 4 | , 'asia'
 5 | , 'australasia'
 6 | , 'backward'
 7 | , 'etcetera'
 8 | , 'europe'
 9 | , 'factory'
10 | , 'northamerica'
11 | , 'pacificnew'
12 | , 'southamerica'
13 | , 'systemv'
14 | ];
15 | 
16 | (function () {
17 | 
18 |   var fs = require('fs')
19 |   , timezoneJS = require('./date')
20 |   , EXCLUDED = new RegExp('README|Makefile|factory|(\\.+)', 'i');
21 | 
22 |   function parse(args) {
23 |     // Upgrade passed script args to real Array
24 |     if (args.length < 3) {
25 |       console.log('Usage: node node-preparse.js zoneFileDirectory [exemplarCities] > outputfile.json');
26 |       console.log('Ex. >>> node node-preparse.js olson_files "Asia/Tokyo, America/New_York, Europe/London" > major_cities.json');
27 |       console.log('Ex. >>> node node-preparse.js olson_files > all_cities.json');
28 |       return;
29 |     }
30 |     var baseDir = args[2]
31 |     , cities = args[3]
32 |     , result = {}
33 |     , _tz = timezoneJS.timezone;
34 | 
35 |     _tz.loadingScheme = _tz.loadingSchemes.MANUAL_LOAD;
36 |     _tz.zoneFiles = files;
37 | 
38 |     for (var i = 0; i < _tz.zoneFiles.length; i++) {
39 |       var zoneFile = _tz.zoneFiles[i];
40 |       if (EXCLUDED.test(zoneFile)) continue;
41 |       var zoneData = fs.readFileSync(baseDir + '/' + zoneFile, 'utf8');
42 |       _tz.parseZones(zoneData);
43 |     }
44 |     if (cities) {
45 |       cities = cities.replace(/ /g, '').split(',');
46 |       var zones = {};
47 |       var rules = {};
48 |       for (var i = 0; i < cities.length; i++) {
49 |         var city = cities[i];
50 |         zones[city] = _tz.zones[city];
51 |       }
52 |       for (var n in zones) {
53 |         var zList = zones[n];
54 |         for (var i = 0; i < zList.length; i++) {
55 |           var ruleKey = zList[i][1];
56 |           rules[ruleKey] = _tz.rules[ruleKey];
57 |         }
58 |       }
59 |       result.zones = zones;
60 |       result.rules = rules;
61 |     }
62 |     else {
63 |       result.zones = _tz.zones;
64 |       result.rules = _tz.rules;
65 |     }
66 |     console.log(JSON.stringify(result, function(key, value) {
67 |       if (typeof(value) == "number") {
68 |         return value.toString()
69 |       }
70 |       return value
71 |     }));
72 |   }
73 | 
74 |   module.exports = parse(process.argv);
75 | 
76 | }).call(this);
77 | 


--------------------------------------------------------------------------------
/src/preparse.js:
--------------------------------------------------------------------------------
 1 | 
 2 | function readText(uri){
 3 |   var jf = new java.io.File(uri);
 4 |   var sb = new java.lang.StringBuffer();
 5 |   var input = new java.io.BufferedReader(new java.io.FileReader(jf));
 6 |   var line = "";
 7 |   var str = "";
 8 |   while((line = input.readLine()) != null){
 9 |     sb.append(line);
10 |     sb.append(java.lang.System.getProperty("line.separator"));
11 |   }
12 |   // Cast to real JS String
13 |   str += sb.toString();
14 |   return str;
15 | }
16 | 
17 | function main(args) {
18 |   // Upgrade passed script args to real Array
19 |   if (!args.length) {
20 |     print('Usage: rhino preparse.js zoneFileDirectory [exemplarCities] > outputfile.json');
21 |     print('Ex. >>> rhino preparse.js olson_files "Asia/Tokyo, America/New_York, Europe/London" > major_cities.json');
22 |     print('Ex. >>> rhino preparse.js olson_files > all_cities.json');
23 |     return;
24 |   }
25 |   var baseDir = args[0];
26 |   var cities = args[1];
27 |   load('date.js');
28 |   load('../../src/json.js');
29 |   var _tz = fleegix.date.timezone;
30 |   _tz.loadingScheme = _tz.loadingSchemes.MANUAL_LOAD;
31 |   for (var i = 0; i < _tz.zoneFiles.length; i++) {
32 |     var zoneFile = _tz.zoneFiles[i];
33 |     var zoneData = readText(baseDir + '/' + zoneFile);
34 |     _tz.parseZones(zoneData);
35 |   }
36 |   var result = {};
37 |   if (cities) {
38 |     cities = cities.replace(/ /g, '').split(',');
39 |     var zones = {};
40 |     var rules = {};
41 |     for (var i = 0; i < cities.length; i++) {
42 |       var city = cities[i];
43 |       zones[city] = _tz.zones[city];
44 |     }
45 |     for (var n in zones) {
46 |       var zList = zones[n];
47 |       for (var i = 0; i < zList.length; i++) {
48 |         var ruleKey = zList[i][1];
49 |         rules[ruleKey] = _tz.rules[ruleKey];
50 |       }
51 |     }
52 |     result.zones = zones;
53 |     result.rules = rules;
54 |   }
55 |   else {
56 |     result.zones = _tz.zones;
57 |     result.rules = _tz.rules
58 |   }
59 |   result = fleegix.json.serialize(result);
60 |   print(result);
61 | }
62 | 
63 | main(arguments);
64 | 
65 | 
66 | 


--------------------------------------------------------------------------------
/src/strip_olson_comments.rb:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/ruby
 2 |  #
 3 |  # Copyright 2009 Matthew Eernisse (mde@fleegix.org)
 4 |  #
 5 |  # Licensed under the Apache License, Version 2.0 (the "License");
 6 |  # you may not use this file except in compliance with the License.
 7 |  # You may obtain a copy of the License at
 8 |  #
 9 |  #   http://www.apache.org/licenses/LICENSE-2.0
10 |  #
11 |  # Unless required by applicable law or agreed to in writing, software
12 |  # distributed under the License is distributed on an "AS IS" BASIS,
13 |  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 |  # See the License for the specific language governing permissions and
15 |  # limitations under the License.
16 |  #
17 |  # This is a sample script for stripping the copious comments
18 |  # from Olson timezone data files.
19 |  #
20 | def clean_file(file_path, target_path=false)
21 |   t = File.read(file_path)
22 |   t.gsub!(/^#.*\n/, '')
23 |   t.gsub!(/^\n/, '')
24 |   if target_path
25 |     File.open(target_path, 'w') do |targ|
26 |       targ.puts t
27 |     end
28 |   else
29 |     print t
30 |   end
31 | end
32 | 
33 | 
34 | if ARGV.length == 0
35 |   print "Usage: strip_comments.rb /path/to/input/file\n"
36 |   print "- puts results into standard output (console) \n"
37 |   print "Use strip_comments.rb /path/to/input/file | /path/to/input/result_file to fill other file \n\n"
38 |   print "Convert all tz files in folder: strip_comments.rb /path/to/folder\n"
39 |   print "- will get all files in folder without extension and creates \"input_file_name.tz\" files filled clean content "
40 |   print "in same folder\n "
41 |   exit
42 | else
43 |   path = ARGV[0]
44 | end
45 | 
46 | if File::directory?(path)
47 |   Dir.foreach(path) do |entry|
48 |     unless entry =~ /\./
49 |       fn = File::join(path, entry)
50 |       clean_file(fn, "#{fn}.tz")
51 |     end
52 |   end
53 | else
54 |   clean_file(path)
55 | end
56 | 
57 | 


--------------------------------------------------------------------------------