timezone-aware 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d122047b6267e0a9514a21357684487db632a1e5
+  data.tar.gz: 115c61829fe5041a0eaf34fa247d602faf5dee32
+SHA512:
+  metadata.gz: adb37c47ede7ddd973eceaf7a4952147214ee309e8491a1ac1778834e489a6ba999965e8e1e811800921148dfdbeb2e7ad8e56bd40f545d8b89f801494288168
+  data.tar.gz: 0ef8a8815079267ea26c5beae7e6190f69f3e8dc0310d2f4b561a8c1a5c79524d7c668776d4c9aa3e344be89477cf31ff9dedf0c0d5ced413d6d25ce8845ba83

data/.gitignore

@@ -0,0 +1,16 @@
+.DS_Store
+*~
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in timezone_aware.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Geoff Hayes
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# TimezoneAware
+
+Timezone aware uses JavaScript to detect a user's timezone.  After the user's own timezone is detected (i.e. after the first request), `Time.zone` is set automatically in an `around_filter` for each request.  In your views and controllers, you can simply call `Time.zone.now` and know this will be in the user's local time.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'timezone-aware'
+```
+
+Add `timezone-aware.js` to `application.js`
+
+```javascript
+//=require timezone-aware
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install timezone-aware
+
+## Usage
+
+Timezone aware automatically sets `Time.zone` during each request.  After the JavaScript determines the user's timezone (via [jstz.js](http://pellepim.bitbucket.org/jstz/)), we set a cookie `time_zone`.  Timezone aware then sets `Time.zone` based on this cookie in an `around_filter`.
+
+**Note: this is not thread safe as global Time.zone is being set for each request.**
+
+## Examples
+
+An example view: **home.html.erb**
+```ruby
+The time is now <%= Time.zone.now %>
+```
+
+Converting time zone back and forth
+```ruby
+Time.now.utc.in_time_zone(Time.zone)
+```
+
+## TODO
+
+* Add Poltergiest test cases
+* Explore ways to get correct timezone on first request
+* Explore ways to make thread safe
+
+## Contributing
+
+1. Fork it ( https://github.com/hayesgm/timezone-aware/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/app/assets/javascripts/timezone-aware.js

@@ -0,0 +1,23 @@
+//= require jstz
+//= require docCookies
+
+/**
+ * @author Geoffrey Hayes
+ */
+
+(function(jstz, docCookies){
+  
+  var timezoneAware = function() {
+    if ( ! docCookies.getItem('time_zone') ) {
+      var timezone = jstz.determine();
+      
+      if (timezone) {
+        docCookies.setItem('time_zone', timezone.name(), 60*60*24*7, '/');
+      }
+    }
+  };
+
+  // Run automatically
+  timezoneAware();
+
+})(jstz, docCookies);

data/lib/timezone-aware.rb

@@ -0,0 +1,6 @@
+require 'timezone-aware/version'
+require 'timezone-aware/engine'
+
+module TimezoneAware
+
+end

data/lib/timezone-aware/engine.rb

@@ -0,0 +1,13 @@
+require 'timezone-aware/helpers'
+
+module TimezoneAware
+  module Rails
+    class Engine < ::Rails::Engine
+      initializer "timezone-aware.load_helpers" do
+        ActiveSupport.on_load(:action_controller) do
+          include TimezoneAware::Helpers
+        end
+      end
+    end
+  end
+end

data/lib/timezone-aware/helpers.rb

@@ -0,0 +1,29 @@
+require 'active_support/concern'
+
+module TimezoneAware
+  module Helpers
+    extend ActiveSupport::Concern
+
+    # Gets timezone
+    def user_time_zone
+      ActiveSupport::TimeZone[cookies[:time_zone]] if cookies[:time_zone]
+    end
+
+    # Note, this is not thread safe
+    def set_time_zone
+      old_time_zone = Time.zone
+
+      new_time_zone = user_time_zone()
+      
+      Time.zone = new_time_zone if new_time_zone
+
+      yield
+    ensure # make sure we restore old time zone
+      Time.zone = old_time_zone
+    end
+
+    included do
+      around_filter :set_time_zone
+    end
+  end
+end

data/lib/timezone-aware/version.rb

@@ -0,0 +1,3 @@
+module TimezoneAware
+  VERSION = "0.0.1"
+end

data/timezone-aware.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'timezone-aware/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "timezone-aware"
+  spec.version       = TimezoneAware::VERSION
+  spec.authors       = ["Geoff Hayes"]
+  spec.email         = ["hayesgm@gmail.com"]
+  spec.summary       = %q{Rails timezone set automatically to browser's own timezone.}
+  spec.description   = %q{Timezone Aware tracks a user's timezone and sets Time.zone to that for each individual request.}
+  spec.homepage      = "http://github.com/hayesgm/timezone-aware"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "railties"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/vendor/assets/javascripts/docCookies.js

@@ -0,0 +1,64 @@
+// From https://developer.mozilla.org/en-US/docs/Web/API/document.cookie
+/*\
+|*|
+|*|  :: cookies.js ::
+|*|
+|*|  A complete cookies reader/writer framework with full unicode support.
+|*|
+|*|  Revision #1 - September 4, 2014
+|*|
+|*|  https://developer.mozilla.org/en-US/docs/Web/API/document.cookie
+|*|  https://developer.mozilla.org/User:fusionchess
+|*|
+|*|  This framework is released under the GNU Public License, version 3 or later.
+|*|  http://www.gnu.org/licenses/gpl-3.0-standalone.html
+|*|
+|*|  Syntaxes:
+|*|
+|*|  * docCookies.setItem(name, value[, end[, path[, domain[, secure]]]])
+|*|  * docCookies.getItem(name)
+|*|  * docCookies.removeItem(name[, path[, domain]])
+|*|  * docCookies.hasItem(name)
+|*|  * docCookies.keys()
+|*|
+\*/
+
+var docCookies = {
+  getItem: function (sKey) {
+    if (!sKey) { return null; }
+    return decodeURIComponent(document.cookie.replace(new RegExp("(?:(?:^|.*;)\\s*" + encodeURIComponent(sKey).replace(/[\-\.\+\*]/g, "\\$&") + "\\s*\\=\\s*([^;]*).*$)|^.*$"), "$1")) || null;
+  },
+  setItem: function (sKey, sValue, vEnd, sPath, sDomain, bSecure) {
+    if (!sKey || /^(?:expires|max\-age|path|domain|secure)$/i.test(sKey)) { return false; }
+    var sExpires = "";
+    if (vEnd) {
+      switch (vEnd.constructor) {
+        case Number:
+          sExpires = vEnd === Infinity ? "; expires=Fri, 31 Dec 9999 23:59:59 GMT" : "; max-age=" + vEnd;
+          break;
+        case String:
+          sExpires = "; expires=" + vEnd;
+          break;
+        case Date:
+          sExpires = "; expires=" + vEnd.toUTCString();
+          break;
+      }
+    }
+    document.cookie = encodeURIComponent(sKey) + "=" + encodeURIComponent(sValue) + sExpires + (sDomain ? "; domain=" + sDomain : "") + (sPath ? "; path=" + sPath : "") + (bSecure ? "; secure" : "");
+    return true;
+  },
+  removeItem: function (sKey, sPath, sDomain) {
+    if (!this.hasItem(sKey)) { return false; }
+    document.cookie = encodeURIComponent(sKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 GMT" + (sDomain ? "; domain=" + sDomain : "") + (sPath ? "; path=" + sPath : "");
+    return true;
+  },
+  hasItem: function (sKey) {
+    if (!sKey) { return false; }
+    return (new RegExp("(?:^|;\\s*)" + encodeURIComponent(sKey).replace(/[\-\.\+\*]/g, "\\$&") + "\\s*\\=")).test(document.cookie);
+  },
+  keys: function () {
+    var aKeys = document.cookie.replace(/((?:^|\s*;)[^\=]+)(?=;|$)|^\s*|\s*(?:\=[^;]*)?(?:\1|$)/g, "").split(/\s*(?:\=[^;]*)?;\s*/);
+    for (var nLen = aKeys.length, nIdx = 0; nIdx < nLen; nIdx++) { aKeys[nIdx] = decodeURIComponent(aKeys[nIdx]); }
+    return aKeys;
+  }
+};

data/vendor/assets/javascripts/jstz.js

@@ -0,0 +1,348 @@
+/**
+ * This script gives you the zone info key representing your device's time zone setting.
+ *
+ * @name jsTimezoneDetect
+ * @version 1.0.4
+ * @author Jon Nylander
+ * @license MIT License - http://www.opensource.org/licenses/mit-license.php
+ *
+ * For usage and examples, visit:
+ * http://pellepim.bitbucket.org/jstz/
+ *
+ * Copyright (c) Jon Nylander
+ */
+
+/*jslint undef: true */
+/*global console, exports*/
+
+(function(root) {
+  /**
+   * Namespace to hold all the code for timezone detection.
+   */
+  var jstz = (function () {
+      'use strict';
+      var HEMISPHERE_SOUTH = 's',
+
+          /**
+           * Gets the offset in minutes from UTC for a certain date.
+           * @param {Date} date
+           * @returns {Number}
+           */
+          get_date_offset = function (date) {
+              var offset = -date.getTimezoneOffset();
+              return (offset !== null ? offset : 0);
+          },
+
+          get_date = function (year, month, date) {
+              var d = new Date();
+              if (year !== undefined) {
+                d.setFullYear(year);
+              }
+              d.setDate(date);
+              d.setMonth(month);
+              return d;
+          },
+
+          get_january_offset = function (year) {
+              return get_date_offset(get_date(year, 0 ,2));
+          },
+
+          get_june_offset = function (year) {
+
+              return get_date_offset(get_date(year, 5, 2));
+          },
+
+          /**
+           * Private method.
+           * Checks whether a given date is in daylight savings time.
+           * If the date supplied is after august, we assume that we're checking
+           * for southern hemisphere DST.
+           * @param {Date} date
+           * @returns {Boolean}
+           */
+          date_is_dst = function (date) {
+              var base_offset = ((date.getMonth() > 7 ? get_june_offset(date.getFullYear())
+                                                  : get_january_offset(date.getFullYear()))),
+                  date_offset = get_date_offset(date);
+
+
+              return (base_offset - date_offset) !== 0;
+          },
+
+          /**
+           * This function does some basic calculations to create information about
+           * the user's timezone.
+           *
+           * Returns a key that can be used to do lookups in jstz.olson.timezones.
+           *
+           * @returns {String}
+           */
+
+          lookup_key = function () {
+              var january_offset = get_january_offset(),
+                  june_offset = get_june_offset(),
+                  diff = get_january_offset() - get_june_offset();
+
+              if (diff < 0) {
+                  return january_offset + ",1";
+              } else if (diff > 0) {
+                  return june_offset + ",1," + HEMISPHERE_SOUTH;
+              }
+
+              return january_offset + ",0";
+          },
+
+          /**
+           * Uses get_timezone_info() to formulate a key to use in the olson.timezones dictionary.
+           *
+           * Returns a primitive object on the format:
+           * {'timezone': TimeZone, 'key' : 'the key used to find the TimeZone object'}
+           *
+           * @returns Object
+           */
+          determine = function () {
+              var key = lookup_key();
+              return new jstz.TimeZone(jstz.olson.timezones[key]);
+          },
+          
+          /**
+           * This object contains information on when daylight savings starts for
+           * different timezones.
+           *
+           * The list is short for a reason. Often we do not have to be very specific
+           * to single out the correct timezone. But when we do, this list comes in
+           * handy.
+           *
+           * Each value is a date denoting when daylight savings starts for that timezone.
+           */
+          dst_start_for = function (tz_name) {
+
+            var ru_pre_dst_change = new Date(2010, 6, 15, 1, 0, 0, 0), // In 2010 Russia had DST, this allows us to detect Russia :)
+                dst_starts = {
+                    'America/Denver':       new Date(2011, 2, 13, 3, 0, 0, 0),
+                    'America/Mazatlan':     new Date(2011, 3, 3, 3, 0, 0, 0),
+                    'America/Chicago':      new Date(2011, 2, 13, 3, 0, 0, 0),
+                    'America/Mexico_City':  new Date(2011, 3, 3, 3, 0, 0, 0),
+                    'America/Asuncion':     new Date(2012, 9, 7, 3, 0, 0, 0),
+                    'America/Santiago':     new Date(2012, 9, 3, 3, 0, 0, 0),
+                    'America/Campo_Grande': new Date(2012, 9, 21, 5, 0, 0, 0),
+                    'America/Montevideo':   new Date(2011, 9, 2, 3, 0, 0, 0),
+                    'America/Sao_Paulo':    new Date(2011, 9, 16, 5, 0, 0, 0),
+                    'America/Los_Angeles':  new Date(2011, 2, 13, 8, 0, 0, 0),
+                    'America/Santa_Isabel': new Date(2011, 3, 5, 8, 0, 0, 0),
+                    'America/Havana':       new Date(2012, 2, 10, 2, 0, 0, 0),
+                    'America/New_York':     new Date(2012, 2, 10, 7, 0, 0, 0),
+                    'Asia/Beirut':          new Date(2011, 2, 27, 1, 0, 0, 0),
+                    'Europe/Helsinki':      new Date(2011, 2, 27, 4, 0, 0, 0),
+                    'Europe/Istanbul':      new Date(2011, 2, 28, 5, 0, 0, 0),
+                    'Asia/Damascus':        new Date(2011, 3, 1, 2, 0, 0, 0),
+                    'Asia/Jerusalem':       new Date(2011, 3, 1, 6, 0, 0, 0),
+                    'Asia/Gaza':            new Date(2009, 2, 28, 0, 30, 0, 0),
+                    'Africa/Cairo':         new Date(2009, 3, 25, 0, 30, 0, 0),
+                    'Pacific/Auckland':     new Date(2011, 8, 26, 7, 0, 0, 0),
+                    'Pacific/Fiji':         new Date(2010, 11, 29, 23, 0, 0, 0),
+                    'America/Halifax':      new Date(2011, 2, 13, 6, 0, 0, 0),
+                    'America/Goose_Bay':    new Date(2011, 2, 13, 2, 1, 0, 0),
+                    'America/Miquelon':     new Date(2011, 2, 13, 5, 0, 0, 0),
+                    'America/Godthab':      new Date(2011, 2, 27, 1, 0, 0, 0),
+                    'Europe/Moscow':        ru_pre_dst_change,
+                    'Asia/Yekaterinburg':   ru_pre_dst_change,
+                    'Asia/Omsk':            ru_pre_dst_change,
+                    'Asia/Krasnoyarsk':     ru_pre_dst_change,
+                    'Asia/Irkutsk':         ru_pre_dst_change,
+                    'Asia/Yakutsk':         ru_pre_dst_change,
+                    'Asia/Vladivostok':     ru_pre_dst_change,
+                    'Asia/Kamchatka':       ru_pre_dst_change,
+                    'Europe/Minsk':         ru_pre_dst_change,
+                    'Australia/Perth':      new Date(2008, 10, 1, 1, 0, 0, 0)
+                };
+
+              return dst_starts[tz_name];
+          };
+
+      return {
+          determine: determine,
+          date_is_dst: date_is_dst,
+          dst_start_for: dst_start_for 
+      };
+  }());
+
+  /**
+   * Simple object to perform ambiguity check and to return name of time zone.
+   */
+  jstz.TimeZone = function (tz_name) {
+      'use strict';
+        /**
+         * The keys in this object are timezones that we know may be ambiguous after
+         * a preliminary scan through the olson_tz object.
+         *
+         * The array of timezones to compare must be in the order that daylight savings
+         * starts for the regions.
+         * 
+         * @TODO: Once 2013 is upon us, remove Asia/Gaza from the Beirut ambiguity list,
+         * by then it should suffice that it lives in the Africa/Johannesburg check.
+         */
+      var AMBIGUITIES = {
+              'America/Denver':       ['America/Denver', 'America/Mazatlan'],
+              'America/Chicago':      ['America/Chicago', 'America/Mexico_City'],
+              'America/Santiago':     ['America/Santiago', 'America/Asuncion', 'America/Campo_Grande'],
+              'America/Montevideo':   ['America/Montevideo', 'America/Sao_Paulo'],
+              'Asia/Beirut':          ['Asia/Beirut', 'Europe/Helsinki', 'Europe/Istanbul', 'Asia/Damascus', 'Asia/Jerusalem', 'Asia/Gaza'],
+              'Pacific/Auckland':     ['Pacific/Auckland', 'Pacific/Fiji'],
+              'America/Los_Angeles':  ['America/Los_Angeles', 'America/Santa_Isabel'],
+              'America/New_York':     ['America/Havana', 'America/New_York'],
+              'America/Halifax':      ['America/Goose_Bay', 'America/Halifax'],
+              'America/Godthab':      ['America/Miquelon', 'America/Godthab'],
+              'Asia/Dubai':           ['Europe/Moscow'],
+              'Asia/Dhaka':           ['Asia/Yekaterinburg'],
+              'Asia/Jakarta':         ['Asia/Omsk'],
+              'Asia/Shanghai':        ['Asia/Krasnoyarsk', 'Australia/Perth'],
+              'Asia/Tokyo':           ['Asia/Irkutsk'],
+              'Australia/Brisbane':   ['Asia/Yakutsk'],
+              'Pacific/Noumea':       ['Asia/Vladivostok'],
+              'Pacific/Tarawa':       ['Asia/Kamchatka'],
+              'Africa/Johannesburg':  ['Asia/Gaza', 'Africa/Cairo'],
+              'Asia/Baghdad':         ['Europe/Minsk']
+          },
+
+          timezone_name = tz_name,
+          
+          /**
+           * Checks if a timezone has possible ambiguities. I.e timezones that are similar.
+           *
+           * For example, if the preliminary scan determines that we're in America/Denver.
+           * We double check here that we're really there and not in America/Mazatlan.
+           *
+           * This is done by checking known dates for when daylight savings start for different
+           * timezones during 2010 and 2011.
+           */
+          ambiguity_check = function () {
+              var ambiguity_list = AMBIGUITIES[timezone_name],
+                  length = ambiguity_list.length,
+                  i = 0,
+                  tz = ambiguity_list[0];
+
+              for (; i < length; i += 1) {
+                  tz = ambiguity_list[i];
+
+                  if (jstz.date_is_dst(jstz.dst_start_for(tz))) {
+                      timezone_name = tz;
+                      return;
+                  }
+              }
+          },
+
+          /**
+           * Checks if it is possible that the timezone is ambiguous.
+           */
+          is_ambiguous = function () {
+              return typeof (AMBIGUITIES[timezone_name]) !== 'undefined';
+          };
+
+      if (is_ambiguous()) {
+          ambiguity_check();
+      }
+
+      return {
+          name: function () {
+              return timezone_name;
+          }
+      };
+  };
+
+  jstz.olson = {};
+
+  /*
+   * The keys in this dictionary are comma separated as such:
+   *
+   * First the offset compared to UTC time in minutes.
+   *
+   * Then a flag which is 0 if the timezone does not take daylight savings into account and 1 if it
+   * does.
+   *
+   * Thirdly an optional 's' signifies that the timezone is in the southern hemisphere,
+   * only interesting for timezones with DST.
+   *
+   * The mapped arrays is used for constructing the jstz.TimeZone object from within
+   * jstz.determine_timezone();
+   */
+  jstz.olson.timezones = {
+      '-720,0'   : 'Etc/GMT+12',
+      '-660,0'   : 'Pacific/Pago_Pago',
+      '-600,1'   : 'America/Adak',
+      '-600,0'   : 'Pacific/Honolulu',
+      '-570,0'   : 'Pacific/Marquesas',
+      '-540,0'   : 'Pacific/Gambier',
+      '-540,1'   : 'America/Anchorage',
+      '-480,1'   : 'America/Los_Angeles',
+      '-480,0'   : 'Pacific/Pitcairn',
+      '-420,0'   : 'America/Phoenix',
+      '-420,1'   : 'America/Denver',
+      '-360,0'   : 'America/Guatemala',
+      '-360,1'   : 'America/Chicago',
+      '-360,1,s' : 'Pacific/Easter',
+      '-300,0'   : 'America/Bogota',
+      '-300,1'   : 'America/New_York',
+      '-270,0'   : 'America/Caracas',
+      '-240,1'   : 'America/Halifax',
+      '-240,0'   : 'America/Santo_Domingo',
+      '-240,1,s' : 'America/Santiago',
+      '-210,1'   : 'America/St_Johns',
+      '-180,1'   : 'America/Godthab',
+      '-180,0'   : 'America/Argentina/Buenos_Aires',
+      '-180,1,s' : 'America/Montevideo',
+      '-120,0'   : 'Etc/GMT+2',
+      '-120,1'   : 'Etc/GMT+2',
+      '-60,1'    : 'Atlantic/Azores',
+      '-60,0'    : 'Atlantic/Cape_Verde',
+      '0,0'      : 'Etc/UTC',
+      '0,1'      : 'Europe/London',
+      '60,1'     : 'Europe/Berlin',
+      '60,0'     : 'Africa/Lagos',
+      '60,1,s'   : 'Africa/Windhoek',
+      '120,1'    : 'Asia/Beirut',
+      '120,0'    : 'Africa/Johannesburg',
+      '180,0'    : 'Asia/Baghdad',
+      '180,1'    : 'Europe/Moscow',
+      '210,1'    : 'Asia/Tehran',
+      '240,0'    : 'Asia/Dubai',
+      '240,1'    : 'Asia/Baku',
+      '270,0'    : 'Asia/Kabul',
+      '300,1'    : 'Asia/Yekaterinburg',
+      '300,0'    : 'Asia/Karachi',
+      '330,0'    : 'Asia/Kolkata',
+      '345,0'    : 'Asia/Kathmandu',
+      '360,0'    : 'Asia/Dhaka',
+      '360,1'    : 'Asia/Omsk',
+      '390,0'    : 'Asia/Rangoon',
+      '420,1'    : 'Asia/Krasnoyarsk',
+      '420,0'    : 'Asia/Jakarta',
+      '480,0'    : 'Asia/Shanghai',
+      '480,1'    : 'Asia/Irkutsk',
+      '525,0'    : 'Australia/Eucla',
+      '525,1,s'  : 'Australia/Eucla',
+      '540,1'    : 'Asia/Yakutsk',
+      '540,0'    : 'Asia/Tokyo',
+      '570,0'    : 'Australia/Darwin',
+      '570,1,s'  : 'Australia/Adelaide',
+      '600,0'    : 'Australia/Brisbane',
+      '600,1'    : 'Asia/Vladivostok',
+      '600,1,s'  : 'Australia/Sydney',
+      '630,1,s'  : 'Australia/Lord_Howe',
+      '660,1'    : 'Asia/Kamchatka',
+      '660,0'    : 'Pacific/Noumea',
+      '690,0'    : 'Pacific/Norfolk',
+      '720,1,s'  : 'Pacific/Auckland',
+      '720,0'    : 'Pacific/Tarawa',
+      '765,1,s'  : 'Pacific/Chatham',
+      '780,0'    : 'Pacific/Tongatapu',
+      '780,1,s'  : 'Pacific/Apia',
+      '840,0'    : 'Pacific/Kiritimati'
+  };
+
+  if (typeof exports !== 'undefined') {
+    exports.jstz = jstz;
+  } else {
+    root.jstz = jstz;
+  }
+})(this);

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: timezone-aware
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Geoff Hayes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Timezone Aware tracks a user's timezone and sets Time.zone to that for
+  each individual request.
+email:
+- hayesgm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascripts/timezone-aware.js
+- lib/timezone-aware.rb
+- lib/timezone-aware/engine.rb
+- lib/timezone-aware/helpers.rb
+- lib/timezone-aware/version.rb
+- timezone-aware.gemspec
+- vendor/assets/javascripts/docCookies.js
+- vendor/assets/javascripts/jstz.js
+homepage: http://github.com/hayesgm/timezone-aware
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Rails timezone set automatically to browser's own timezone.
+test_files: []
+has_rdoc: