exvo_globalize 0.4.0 → 0.5.0

data/README.md

@@ -67,11 +67,83 @@ Basic support for I18n in the javascript is included. In order for it to work yo
 Now you can use translations inside your javascript:
 
 ```js
-t("new")
-=> "New"
+t("hello")
+=> "Hello world!"
 ```
 
-The above, of course, expects you to have the `:new` key for the current `I18n.locale` in one of your `config/locales/*.yml` files.
+The above, of course, expects you to have the `:hello` key for the current `I18n.locale` in one of your `config/locales/*.yml` files.
+
+
+The following I18n features are supported in javascript:
+
+
+### Locale fallback
+
+If there is no translation in the desired `locale`, there will be another check performed to see if there is a translation available in the `default_locale`. If there is, display it.
+
+By default, when including two javascript tags in your application (see installation notes), you will have translations in the desired locale merged with translations for the default_locale available in the javascript.
+
+
+### Localization
+
+All standard I18n keys (see `config/locales/*` in this gem’s directory) are used for various localization rules. Examples follows (for `:en` locale).
+
+
+#### Numbers
+
+```js
+I18n.toNumber(1234)
+=> "1,234.000"
+
+l("number", 1234)
+=> "1,234.000"
+```
+
+#### Percentages
+
+```js
+I18n.toPercentage(1234)
+=> "1234.000%"
+
+l("percentage", 1234)
+=> "1234.000%"
+```
+
+#### Currencies
+
+```js
+I18n.toCurrency(12)
+=> "12,00 USD"
+
+l("currency", 12)
+=> "12,00 USD"
+```
+
+
+#### Numbers in human sizes
+
+```js
+I18n.toHumanSize(1024)
+=> "1KB"
+```
+
+
+#### Dates and times
+
+```js
+// uses ERB Ruby interpolation
+I18n.strftime(I18n.parseDate("<%= Time.now %>"), "%Y/%m/%d %H:%M")
+=> "2011/09/14 12:03"
+
+// uses formats from `config/locale/en.yml` file
+I18n.l("date.formats.default", "Wed Sep 14 12:03:11 +0200 2011")
+=> "14-09-2011"
+
+I18n.l("date.formats.long", "2011-09-14")
+=> "September 14, 2011"
+```
+
+See `spec/javascripts/exvo_globalize_i18n_spec.js` for all available localization forms.
 
 
 
@@ -139,4 +211,13 @@ http://johnbintz.github.com/jasmine-headless-webkit/
 
 
 
+## Copyrights
+
+exvo_globalize is based on the following projects:
+https://github.com/svenfuchs/i18n
+https://github.com/svenfuchs/rails-i18n/
+https://github.com/toretore/babilu
+https://github.com/spider-network/i18n-js
+
+
 Copyright © 2011 Exvo.com Development BV, released under the MIT license

data/Rakefile

@@ -2,7 +2,7 @@ require 'bundler/gem_tasks'
 
 require 'rspec/core'
 require 'rspec/core/rake_task'
-import 'lib/tasks/jasmine.rake'
+
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end

data/app/assets/javascripts/exvo_globalize_i18n.js

@@ -1,90 +1,374 @@
-var I18n = (function() {
-    // Replace {{foo}} with obj.foo
-    function interpolate(string, object) {
-        return string.replace(/\{\{([^}]+)\}\}/g, function() {
-            return object[arguments[1]] || arguments[0];
-        });
-    };
+(function() {
 
-    // Split "foo.bar" to ["foo", "bar"] if key is a string
-    function keyToArray(key) {
-        if(!key) {
-            return [];
-        }
-        if(typeof key != "string") {
-            return key;
-        }
-        return key.split('.');
-    };
+  I18n = {};
 
-    // Looks up a translation using an array of strings where the last
-    // is the key and any string before that define the scope. The
-    // current locale is always prepended and does not need to be
-    // provided. The second parameter is an array of strings used as
-    // defaults if the key can not be found. If a key starts with ":"
-    // it is used as a key for lookup. This method does not perform
-    // pluralization or interpolation.
-    function lookup(keys, defaults) {
-        var i = 0, value = I18n.translations;
-        defaults = (typeof defaults === "string") ? [defaults] : (defaults || []);
-        while(keys[i]) {
-            value = value && value[keys[i]];
-            i++;
-        }
-        if(value) {
-            return value;
-        } else {
-            if(defaults.length === 0) {
-                return null;
-            } else if (defaults[0].substr(0,1) === ':') {
-                return lookup(keys.slice(0, keys.length - 1).concat(keyToArray(defaults[0].substr(1))), defaults.slice(1));
-            } else {
-                return defaults[0];
-            }
+  var interpolatePattern = /%\{([^}]+)\}/g;
+
+  // Replace %{foo} with obj.foo
+  function interpolate(str, obj) {
+    return str.replace(interpolatePattern, function() {
+      return typeof obj[arguments[1]] == 'undefined' ? arguments[0] : obj[arguments[1]];
+    });
+  };
+
+  // Split "foo.bar" to ["foo", "bar"] if key is a string
+  function keyToArray(key) {
+    if (!key) return [];
+    if (typeof key != "string") return key;
+    return key.split('.');
+  };
+
+  function locale() {
+    return I18n.locale || I18n.defaultLocale;
+  };
+
+  I18n.isValidNode = function(obj, node) {
+    // local undefined variable in case another library corrupts window.undefined
+    var undef;
+    return obj[node] !== null && obj[node] !== undef;
+  };
+
+  // Merge serveral hash options, checking if value is set before
+  // overwriting any value. The precedence is from left to right.
+  //
+  // I18n.prepareOptions({name: "John Doe"}, {name: "Mary Doe", role: "user"});
+  // #=> {name: "John Doe", role: "user"}
+  I18n.prepareOptions = function() {
+    var options = {};
+    var opts;
+    var count = arguments.length;
+
+    for (var i = 0; i < count; i++) {
+      opts = arguments[i];
+
+      if (!opts) {
+        continue;
+      }
+
+      for (var key in opts) {
+        if (!this.isValidNode(options, key)) {
+          options[key] = opts[key];
         }
-    };
+      }
+    }
 
-    // Returns other when 0 given
-    function pluralize(value, count) {
-        if(count === undefined) return value;
-        return count === 1 ? value.one : value.other;
-    };
+    return options;
+  };
+
+  // Works mostly the same as the Ruby equivalent, except there are
+  // no symbols in JavaScript, so keys are always strings. The only time
+  // this makes a difference is when differentiating between keys and values
+  // in the defaultValue option. Strings starting with ":" will be considered
+  // to be keys and used for lookup, while other strings are returned as-is.
+  I18n.translate = function(key, opts) {
+    if (typeof key != "string") { // Bulk lookup
+      var a = [], i;
+      for (i=0; i<key.length; i++) {
+        a.push(this.translate(key[i], opts));
+      }
+      return a;
+    } else {
+      opts = opts || {};
+      opts.defaultValue = opts.defaultValue || null;
+      key = keyToArray(opts.scope).concat(keyToArray(key));
+      var value = this.lookup(locale(), key, opts.defaultValue);
+
+      // fall back to I18n.default_locale for missing translations
+      if (value == null && I18n.locale != I18n.default_locale) value = this.lookup(I18n.default_locale, key, opts.defaultLocale);
+
+      if (typeof value != "string" && value) value = this.pluralize(value, opts.count);
+      if (typeof value == "string") value = interpolate(value, opts);
+      if (value == null) value = this.missingTranslation(key)
+      return value;
+    }
+  };
 
-    // Works mostly the same as the Ruby equivalent, except there are
-    // no symbols in JavaScript, so keys are always strings. The only
-    // time this makes a difference is when differentiating between
-    // keys and values in the defaultValue option. Strings starting
-    // with ":" will be considered to be keys and used for lookup,
-    // while other strings are returned as-is.
-    function translate(key, options) {
-        if(typeof key != "string") {
-            // Bulk lookup
-            var a = [], i;
-            for(i = 0; i < key.length; i++) {
-                a.push(translate(key[i], options));
-            }
-            return a;
+  I18n.t = I18n.translate;
+
+  // Looks up a translation using an array of strings where the last
+  // is the key and any string before that define the scope. The current
+  // locale is always prepended and does not need to be provided. The second
+  // parameter is an array of strings used as defaults if the key can not be
+  // found. If a key starts with ":" it is used as a key for lookup.
+  // This method does not perform pluralization or interpolation.
+  I18n.lookup = function(locale, keys, defaults) {
+    var i = 0, value = this.translations[locale];
+    defaults = typeof defaults == "string" ? [defaults] : (defaults || []);
+    while (keys[i]) {
+      value = value && value[keys[i]];
+      i++;
+    }
+    if (value) {
+      return value;
+    } else {
+      if (defaults.length == 0) {
+        return null;
+      } else if (defaults[0].substr(0,1) == ':') {
+        return this.lookup(locale, keys.slice(0, keys.length - 1).concat(keyToArray(defaults[0].substr(1))), defaults.slice(1));
+      } else {
+        return defaults[0];
+      }
+    }
+  };
+
+  I18n.localize = function(scope, value) {
+    switch (scope) {
+      case "currency":
+        return this.toCurrency(value);
+      case "number":
+        scope = this.lookup(locale(), ["number", "format"]);
+        return this.toNumber(value, scope);
+      case "percentage":
+        return this.toPercentage(value);
+      default:
+        if (scope.match(/^(date|time)/)) {
+          return this.toTime(scope, value);
         } else {
-            options = options || {};
-            options.defaultValue = options.defaultValue || null;
-            key = keyToArray(options.scope).concat(keyToArray(key));
-            var value = lookup(key, options.defaultValue);
-            if(typeof value !== "string" && value) {
-                value = pluralize(value, options.count);
-            }
-            if(typeof value === "string") {
-                value = interpolate(value, options);
-            }
-            return value;
+          return value.toString();
         }
     }
+  };
+
+  I18n.l = I18n.localize;
+
+  I18n.parseDate = function(d) {
+    var matches, date;
+    matches = d.toString().match(/(\d{4})-(\d{2})-(\d{2})(?:[ |T](\d{2}):(\d{2}):(\d{2}))?(Z)?/);
+
+    if (matches) {
+      // date/time strings: yyyy-mm-dd hh:mm:ss or yyyy-mm-dd or yyyy-mm-ddThh:mm:ssZ
+      for (var i = 1; i <= 6; i++) {
+        matches[i] = parseInt(matches[i], 10) || 0;
+      }
+
+      // month starts on 0
+      matches[2] -= 1;
+
+      if (matches[7]) {
+        date = new Date(Date.UTC(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6]));
+      } else {
+        date = new Date(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6]);
+      }
+    } else if (typeof(d) == "number") {
+      // UNIX timestamp
+      date = new Date();
+      date.setTime(d);
+    } else {
+      // an arbitrary javascript string
+      date = new Date();
+      date.setTime(Date.parse(d));
+    }
+
+    return date;
+  };
+
+  I18n.toTime = function(scope, d) {
+    var date = this.parseDate(d);
+    var format = this.lookup(locale(), keyToArray(scope));
+
+    if (date.toString().match(/invalid/i)) {
+      return date.toString();
+    }
+
+    if (!format) {
+      return date.toString();
+    }
+
+    return this.strftime(date, format);
+  };
+
+  I18n.strftime = function(date, format) {
+    var options = this.lookup(locale(), ["date"]);
+
+    if (!options) {
+      return date.toString();
+    }
 
-    return {
-        translate: translate,
-        t: translate
+    // get meridian from ":time" i18n key
+    options.time = this.lookup(locale(), ["time"]);
+    if (!options.time || !options.time.am || !options.time.pm) {
+      options.time = { am: "AM", pm: "PM" };
+    }
+
+    var weekDay = date.getDay();
+    var day = date.getDate();
+    var year = date.getFullYear();
+    var month = date.getMonth() + 1;
+    var hour = date.getHours();
+    var hour12 = hour;
+    var meridian = hour > 11 ? "pm" : "am";
+    var secs = date.getSeconds();
+    var mins = date.getMinutes();
+    var offset = date.getTimezoneOffset();
+    var absOffsetHours = Math.floor(Math.abs(offset / 60));
+    var absOffsetMinutes = Math.abs(offset) - (absOffsetHours * 60);
+    var timezoneoffset = (offset > 0 ? "-" : "+") + (absOffsetHours.toString().length < 2 ? "0" + absOffsetHours : absOffsetHours) + (absOffsetMinutes.toString().length < 2 ? "0" + absOffsetMinutes : absOffsetMinutes);
+
+    if (hour12 > 12) {
+      hour12 = hour12 - 12;
+    } else if (hour12 === 0) {
+      hour12 = 12;
+    }
+
+    var padding = function(n) {
+      var s = "0" + n.toString();
+      return s.substr(s.length - 2);
     };
+
+    var f = format;
+    f = f.replace("%a", options.abbr_day_names[weekDay]);
+    f = f.replace("%A", options.day_names[weekDay]);
+    f = f.replace("%b", options.abbr_month_names[month]);
+    f = f.replace("%B", options.month_names[month]);
+    f = f.replace("%d", padding(day));
+    f = f.replace("%-d", day);
+    f = f.replace("%H", padding(hour));
+    f = f.replace("%-H", hour);
+    f = f.replace("%I", padding(hour12));
+    f = f.replace("%-I", hour12);
+    f = f.replace("%m", padding(month));
+    f = f.replace("%-m", month);
+    f = f.replace("%M", padding(mins));
+    f = f.replace("%-M", mins);
+    f = f.replace("%p", options.time[meridian]);
+    f = f.replace("%S", padding(secs));
+    f = f.replace("%-S", secs);
+    f = f.replace("%w", weekDay);
+    f = f.replace("%y", padding(year));
+    f = f.replace("%-y", padding(year).replace(/^0+/, ""));
+    f = f.replace("%Y", year);
+    f = f.replace("%z", timezoneoffset);
+
+    return f;
+  };
+
+  I18n.toNumber = function(number, options) {
+    options = this.prepareOptions(
+      options,
+      this.lookup(locale(), ["number", "format"]),
+      {precision: 3, separator: ".", delimiter: ",", strip_insignificant_zeros: false}
+    );
+
+    var negative = number < 0;
+    var string = Math.abs(number).toFixed(options.precision).toString();
+    var parts = string.split(".");
+
+    number = parts[0];
+    var precision = parts[1];
+
+    var n = [];
+
+    while (number.length > 0) {
+      n.unshift(number.substr(Math.max(0, number.length - 3), 3));
+      number = number.substr(0, number.length -3);
+    }
+
+    var formattedNumber = n.join(options.delimiter);
+
+    if (options.precision > 0) {
+      formattedNumber += options.separator + parts[1];
+    }
+
+    if (negative) {
+      formattedNumber = "-" + formattedNumber;
+    }
+
+    if (options.strip_insignificant_zeros) {
+      var regex = {
+          separator: new RegExp(options.separator.replace(/\./, "\\.") + "$")
+        , zeros: /0+$/
+      };
+
+      formattedNumber = formattedNumber
+        .replace(regex.zeros, "")
+        .replace(regex.separator, "");
+    }
+
+    return formattedNumber;
+  };
+
+  I18n.toCurrency = function(number, options) {
+    options = this.prepareOptions(
+      options,
+      this.lookup(locale(), ["number", "currency", "format"]),
+      this.lookup(locale(), ["number", "format"]),
+      {unit: "$", precision: 2, format: "%u%n", delimiter: ",", separator: "."}
+    );
+
+    number = this.toNumber(number, options);
+    number = options.format
+      .replace("%u", options.unit)
+      .replace("%n", number);
+
+    return number;
+  };
+
+  I18n.toHumanSize = function(number, options) {
+    var kb = 1024
+      , size = number
+      , iterations = 0
+      , unit
+      , precision
+    ;
+
+    while (size >= kb && iterations < 4) {
+      size = size / kb;
+      iterations += 1;
+    }
+
+    if (iterations === 0) {
+      unit = this.t("number.human.storage_units.units.byte", {count: size});
+      precision = 0;
+    } else {
+      unit = this.t("number.human.storage_units.units." + [null, "kb", "mb", "gb", "tb"][iterations]);
+      precision = (size - Math.floor(size) === 0) ? 0 : 1;
+    }
+
+    options = this.prepareOptions(
+      options,
+      {precision: precision, format: "%n%u", delimiter: ""}
+    );
+
+    number = this.toNumber(size, options);
+    number = options.format
+      .replace("%u", unit)
+      .replace("%n", number);
+
+    return number;
+  };
+
+  I18n.toPercentage = function(number, options) {
+    options = this.prepareOptions(
+      options,
+      this.lookup(locale(), ["number", "percentage", "format"]),
+      this.lookup(locale(), ["number", "format"]),
+      {precision: 3, separator: ".", delimiter: ""}
+    );
+
+    number = this.toNumber(number, options);
+    return number + "%";
+  };
+
+  I18n.pluralize = function(value, count) {
+    if (typeof count != 'number') return value;
+    return count == 1 ? value.one : value.other;
+  };
+
+  // Returns '[missing translation: "en.missing"]' when translation is not found
+  I18n.missingTranslation = function(key) {
+    var message = '[missing translation: "' + locale();
+    for (var i in key) {
+      message += "." + key[i];
+    }
+    return message += '"]';
+  };
+
 })();
 
 var t = (function(key, options) {
   return I18n.t(key, options);
 });
+
+var l = (function(scope, value) {
+  return I18n.l(scope, value);
+});

data/app/controllers/globalize_translations_controller.rb

@@ -6,11 +6,10 @@ class GlobalizeTranslationsController < ApplicationController
   layout 'exvo_globalize'
 
   respond_to :html, :json, :js
-  
+
   def show
     @translations = if params[:id].present?
-        hash = I18n.backend.available_translations
-        hash.has_key?(params[:id].to_sym) ? hash[params[:id].to_sym] : {}
+        I18n.backend.available_translations_scoped_by_locale_with_default(params[:id].to_sym)
       else
         I18n.backend.available_app_translations.merge({ :default_locale => I18n.default_locale })
       end
@@ -52,7 +51,7 @@ class GlobalizeTranslationsController < ApplicationController
   end
 
   private
-  
+
   def globalize_translations_authenticator
     # get :show as JSON or JS does not require authentication
     return if params[:action].to_s == 'show' and (request.format.json? or request.format.js?)

data/lib/exvo_globalize/backend/chain.rb

@@ -4,13 +4,24 @@ module I18n
       module Implementation
 
         # Extend the Chain backend with a custom `available_translations` method
-        # returning a combined hash with translations from all chained backends
+        # returning a combined Hash with translations from all chained backends
         def available_translations
           # reverse, so that the translations from the first backend (GlobalizeStore) overwrite/overshadow others
           @available_translations ||= backends.map { |backend| backend.available_translations }.reverse.inject(&:deep_merge)
         end
 
-        # Return a hash only with Application translations
+        # Returns a Hash of translations for the specified locale merged with translations for the default_locale
+        def available_translations_scoped_by_locale_with_default(locale)
+          default_locale_translations = { I18n.default_locale => available_translations.fetch(I18n.default_locale) { {} } }
+
+          if locale != I18n.default_locale
+            default_locale_translations.deep_merge({ locale => available_translations.fetch(locale) { {} } })
+          else
+            default_locale_translations
+          end
+        end
+
+        # Return a Hash only with Application translations
         def available_app_translations
           # save original load_path
           load_path = I18n.load_path

data/lib/exvo_globalize/version.rb

@@ -1,3 +1,3 @@
 module ExvoGlobalize
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec/controllers/globalize_translations_controller_spec.rb

@@ -20,7 +20,7 @@ describe GlobalizeTranslationsController do
       end
 
       it "returns a hash with translations" do
-        assigns(:translations)[:name].should eq("YAML Name")
+        assigns(:translations)[:en][:name].should eq("YAML Name")
       end
     end
 

data/spec/exvo_globalize/globalize_store_spec.rb

@@ -81,4 +81,10 @@ describe ExvoGlobalize do
     I18n.backend.available_translations[:en].has_key?(:title).should be_true
   end
 
+  it "lists all translations for a given locale including translations for the default locale" do
+    translations = I18n.backend.available_translations_scoped_by_locale_with_default(:pl)
+    translations[:en].has_key?(:title).should be_true
+    translations[:pl].has_key?(:mail).should be_true
+  end
+
 end

data/spec/javascripts/exvo_globalize_i18n_spec.js

@@ -1,7 +1,384 @@
-describe("Translation", function() {
+beforeEach(function() {
+  I18n.locale = "en"
+})
+
+describe("Basic translation functionality", function() {
+
+  it("translates the phrase", function() {
+    expect(I18n.translate("world")).toEqual("World")
+  })
+
+  it("translates the phrase for the 'pl' locale", function() {
+    I18n.locale = "pl"
+    expect(I18n.translate("world")).toEqual("Świat")
+  })
+
+  it("translates the phrase using I18n.t()", function() {
+    expect(I18n.t("world")).toEqual("World")
+  })
+
+  it("returns missing translation message when translation is not found", function() {
+    expect(I18n.t("missing")).toMatch(/missing translation/)
+  })
+
+  it("translates the phrase using scoped key with dots as separators", function() {
+    expect(I18n.t("page.intro.heading")).toEqual("Heading")
+  })
+
+  it("translates the phrase using dotted string scope param", function() {
+    expect(I18n.t("heading", {scope: "page.intro"})).toEqual("Heading")
+  })
+
+  it("translates the phrase using Array scope param", function() {
+    expect(I18n.t("heading", {scope: ["page", "intro"]})).toEqual("Heading")
+  })
+
+  it("supports interpolation during translation", function() {
+    expect(I18n.t("hello", {name: "John"})).toEqual("Hello John!")
+  })
+
+})
+
+describe("Global short functions", function() {
+
+  it("translates the phrase using t() global function", function() {
+    expect(t("world")).toEqual("World")
+  })
+
+  it("localizes the number using l() global function", function() {
+    expect(l("number", 1)).toEqual("1.000")
+  })
+
+})
+
+describe("Default value fallback", function() {
+
+  it("ignores defaultValue if translation is found", function() {
+    expect(I18n.t("world", {defaultValue: "New World"})).toEqual("World")
+  })
+
+  it("returns defaultValue if translation is not found", function() {
+    expect(I18n.t("non-existing-key", {defaultValue: "New World"})).toEqual("New World")
+  })
+
+  it("uses defaultValue to do another lookup if it starts with ':'", function() {
+    expect(I18n.t("non-existing-key", {defaultValue: ":world"})).toEqual("World")
+  })
+
+  it("allows an Array as defaultValue and keeps checking each of its keys for translation", function() {
+    expect(I18n.t("non-existing-key", {defaultValue: [":missing", ":world"]})).toEqual("World")
+  })
+
+  it("applies the same scope to the defaultValue as it does to the key", function() {
+    expect(I18n.t("non-existing-key", {scope: "page", defaultValue: [":title"]})).toEqual("Title")
+  })
+
+})
+
+describe("Locale fallback", function() {
+
+  it("falls back to I18n.default_locale when there is no translation available for the requested locale", function() {
+    I18n.locale = "pl"
+    expect(I18n.t("title", {scope: "page"})).toEqual("Title")
+  })
+
+})
+
+describe("Localization of numbers", function() {
+
+  beforeEach(function() {
+    I18n.locale = "pl"
+  })
+
+  it("localizes numbers with default settings", function() {
+    expect(I18n.toNumber(1)).toEqual("1,000")
+    expect(I18n.toNumber(1234567)).toEqual("1 234 567,000")
+    expect(I18n.toNumber(-1)).toEqual("-1,000")
+    expect(I18n.toNumber(-1234567)).toEqual("-1 234 567,000")
+  })
+
+  it("localizes numbers with custom options", function() {
+    expect(I18n.toNumber(1234.19, {precision: 0})).toEqual("1 234")
+    expect(I18n.toNumber(1234, {separator: '-'})).toEqual("1 234-000")
+    expect(I18n.toNumber(1234, {delimiter: '-'})).toEqual("1-234,000")
+    expect(I18n.toNumber(65, {precision: 4, strip_insignificant_zeros: true})).toEqual("65")
+    expect(I18n.toNumber(1.2, {precision: 4, strip_insignificant_zeros: true})).toEqual("1,2")
+  })
+
+  it("localizes numbers using localize() function", function() {
+    expect(I18n.l("number", 1)).toEqual("1,000")
+    expect(I18n.l("number", 1234567)).toEqual("1 234 567,000")
+    expect(I18n.l("number", -1)).toEqual("-1,000")
+    expect(I18n.l("number", -1234567)).toEqual("-1 234 567,000")
+  })
+})
+
+describe("Localization of percentages", function() {
+
+  beforeEach(function() {
+    I18n.locale = "pl"
+  })
+
+  it("localizes percentages with default settings", function() {
+    expect(I18n.toPercentage(1234)).toEqual("1234,00%")
+  })
+
+  it("localizes percentages with custom options", function() {
+    expect(I18n.toPercentage(1234.19, {delimiter: "_", precision: 0})).toEqual("1_234%")
+  })
+
+  it("localizes percentages using localize() function", function() {
+    expect(I18n.l("percentage", 12)).toEqual("12,00%")
+  })
+
+})
+
+describe("Localization of currencies", function() {
+
+  beforeEach(function() {
+    I18n.locale = "pl"
+  })
+
+  it("localizes currencies with default settings", function() {
+    expect(I18n.toCurrency(100.99)).toEqual("PLN 100,99")
+    expect(I18n.toCurrency(1000.99)).toEqual("PLN 1 000,99")
+  })
+
+  it("localizes currencies with custom options", function() {
+    expect(I18n.toCurrency(1234.19, {precision: 0})).toEqual("PLN 1 234")
+    expect(I18n.toCurrency(1234, {unit: "zł"})).toEqual("zł 1 234")
+    expect(I18n.toCurrency(1234, {separator: "-", strip_insignificant_zeros: false})).toEqual("PLN 1 234-00")
+    expect(I18n.toCurrency(1234, {delimiter: ""})).toEqual("PLN 1234")
+    expect(I18n.toCurrency(1234, {format: "%n %u"})).toEqual("1 234 PLN")
+  })
+
+  it("localizes currencies using localize() function", function() {
+    expect(I18n.l("currency", 12)).toEqual("PLN 12")
+  })
+
+})
+
+describe("Localization of human sizes", function() {
+
+  beforeEach(function() {
+    I18n.locale = "pl"
+  })
+
+  it("localizes numbers in human sizes", function() {
+    kb = 1024
+
+    expect(I18n.toHumanSize(1)).toEqual("1bajt")
+    expect(I18n.toHumanSize(102)).toEqual("102bajty")
+
+    expect(I18n.toHumanSize(kb)).toEqual("1KB")
+    expect(I18n.toHumanSize(kb * 1.5)).toEqual("1,5KB")
+
+    expect(I18n.toHumanSize(kb * kb)).toEqual("1MB")
+    expect(I18n.toHumanSize(kb * kb * 1.5)).toEqual("1,5MB")
+
+    expect(I18n.toHumanSize(kb * kb * kb)).toEqual("1GB")
+    expect(I18n.toHumanSize(kb * kb * kb * 1.5)).toEqual("1,5GB")
+
+    expect(I18n.toHumanSize(kb * kb * kb * kb)).toEqual("1TB")
+    expect(I18n.toHumanSize(kb * kb * kb * kb * 1.5)).toEqual("1,5TB")
+
+    expect(I18n.toHumanSize(kb * kb * kb * kb * kb)).toEqual("1024TB")
+  })
+
+  it("localizes numbers in human sizes using custom options", function() {
+    expect(I18n.toHumanSize(1024 * 1.6, {precision: 0})).toEqual("2KB")
+  })
+
+})
+
+describe("Date parsing", function() {
+
+  beforeEach(function() {
+    I18n.locale = "pl"
+  })
+
+  it("parses dates", function() {
+    expected = new Date(2009, 0, 24, 0, 0, 0)
+    actual = I18n.parseDate("2009-01-24")
+    expect(actual.toString()).toEqual(expected.toString())
+
+    expected = new Date(2009, 0, 24, 0, 15, 0)
+    actual = I18n.parseDate("2009-01-24 00:15:00")
+    expect(actual.toString()).toEqual(expected.toString())
+
+    expected = new Date(2009, 0, 24, 0, 0, 15)
+    actual = I18n.parseDate("2009-01-24 00:00:15")
+    expect(actual.toString()).toEqual(expected.toString())
+
+    expected = new Date(2009, 0, 24, 15, 33, 44)
+    actual = I18n.parseDate("2009-01-24 15:33:44")
+    expect(actual.toString()).toEqual(expected.toString())
+
+    expected = new Date(2009, 0, 24, 0, 0, 0)
+    actual = I18n.parseDate(expected.getTime())
+    expect(actual.toString()).toEqual(expected.toString())
+
+    expected = new Date(2009, 0, 24, 0, 0, 0)
+    actual = I18n.parseDate("01/24/2009")
+    expect(actual.toString()).toEqual(expected.toString())
+
+    expected = new Date(2009, 0, 24, 14, 33, 55)
+    actual = I18n.parseDate(expected).toString()
+    expect(actual).toEqual(expected.toString())
+
+    expected = new Date(2009, 0, 24, 15, 33, 44)
+    actual = I18n.parseDate("2009-01-24T15:33:44")
+    expect(actual.toString()).toEqual(expected.toString())
+
+    expected = new Date(Date.UTC(2009, 0, 24, 15, 33, 44))
+    actual = I18n.parseDate("2009-01-24T15:33:44Z")
+    expect(actual.toString()).toEqual(expected.toString())
+  })
+
+  it("formats dates", function() {
+    // 2009-04-26 19:35:44 (Sunday)
+    var date = new Date(2009, 3, 26, 19, 35, 44)
+
+    // short week day
+    expect(I18n.strftime(date, "%a")).toEqual("nie")
+
+    // full week day
+    expect(I18n.strftime(date, "%A")).toEqual("niedziela")
+
+    // short month
+    expect(I18n.strftime(date, "%b")).toEqual("kwi")
+
+    // full month
+    expect(I18n.strftime(date, "%B")).toEqual("kwiecień")
+
+    // day
+    expect(I18n.strftime(date, "%d")).toEqual("26")
+
+    // 24-hour
+    expect(I18n.strftime(date, "%H")).toEqual("19")
+
+    // 12-hour
+    expect(I18n.strftime(date, "%I")).toEqual("07")
+
+    // month
+    expect(I18n.strftime(date, "%m")).toEqual("04")
+
+    // minutes
+    expect(I18n.strftime(date, "%M")).toEqual("35")
+
+    // meridian
+    expect(I18n.strftime(date, "%p")).toEqual("po południu")
+
+    // seconds
+    expect(I18n.strftime(date, "%S")).toEqual("44")
+
+    // week day
+    expect(I18n.strftime(date, "%w")).toEqual("0")
+
+    // short year
+    expect(I18n.strftime(date, "%y")).toEqual("09")
+
+    // full year
+    expect(I18n.strftime(date, "%Y")).toEqual("2009")
+
+    // full date
+    expect(I18n.strftime(date, "%d. %B %Y, godzina %H:%M")).toEqual("26. kwiecień 2009, godzina 19:35")
+  })
+
+  it("formats dates without padding", function() {
+    // 2009-04-26 19:35:44 (Sunday)
+    var date = new Date(2009, 3, 9, 7, 8, 9)
+
+    // 24-hour without padding
+    expect(I18n.strftime(date, "%-H")).toEqual("7")
+
+    // 12-hour without padding
+    expect(I18n.strftime(date, "%-I")).toEqual("7")
+
+    // minutes without padding
+    expect(I18n.strftime(date, "%-M")).toEqual("8")
+
+    // seconds without padding
+    expect(I18n.strftime(date, "%-S")).toEqual("9")
+
+    // short year without padding
+    expect(I18n.strftime(date, "%-y")).toEqual("9")
+
+    // month without padding
+    expect(I18n.strftime(date, "%-m")).toEqual("4")
+
+    // day without padding
+    expect(I18n.strftime(date, "%-d")).toEqual("9")
+  })
+
+  it("formats dates with padding", function() {
+    // 2009-04-26 19:35:44 (Sunday)
+    var date = new Date(2009, 3, 9, 7, 8, 9)
+
+    // 24-hour
+    expect(I18n.strftime(date, "%H")).toEqual("07")
+
+    // 12-hour
+    expect(I18n.strftime(date, "%I")).toEqual("07")
+
+    // minutes
+    expect(I18n.strftime(date, "%M")).toEqual("08")
+
+    // seconds
+    expect(I18n.strftime(date, "%S")).toEqual("09")
+
+    // short year
+    expect(I18n.strftime(date, "%y")).toEqual("09")
+
+    // month
+    expect(I18n.strftime(date, "%m")).toEqual("04")
+
+    // day
+    expect(I18n.strftime(date, "%d")).toEqual("09")
+  })
+
+  it("formats dates with negative time zone", function() {
+    var date = new Date(2009, 3, 26, 19, 35, 44)
+    spyOn(date, "getTimezoneOffset").andReturn(345)
+
+    expect(I18n.strftime(date, "%z")).toMatch(/^(\+|-)[\d]{4}$/)
+    expect(I18n.strftime(date, "%z")).toEqual("-0545")
+  })
+
+  it("formats dates with positive time zone", function() {
+    var date = new Date(2009, 3, 26, 19, 35, 44)
+    spyOn(date, "getTimezoneOffset").andReturn(-345)
+
+    expect(I18n.strftime(date, "%z")).toMatch(/^(\+|-)[\d]{4}$/)
+    expect(I18n.strftime(date, "%z")).toEqual("+0545")
+  })
+
+
+  it("formats dates using hour12 values", function() {
+    var date = new Date(2009, 3, 26, 19, 35, 44)
+    expect(I18n.strftime(date, "%I")).toEqual("07")
+
+    date = new Date(2009, 3, 26, 12, 35, 44)
+    expect(I18n.strftime(date, "%I")).toEqual("12")
+
+    date = new Date(2009, 3, 26, 0, 35, 44)
+    expect(I18n.strftime(date, "%I")).toEqual("12")
+  })
+
+  it("parses and formats a Ruby Time.now.to_s string ", function() {
+    expect(I18n.strftime(I18n.parseDate("Wed Sep 14 12:03:11 +0200 2011"), "%Y/%m/%d %H:%M")).toEqual("2011/09/14 12:03")
+  })
+
+  it("localizes date strings", function() {
+    expect(I18n.l("date.formats.default", "2009-11-29")).toEqual("29-11-2009")
+    expect(I18n.l("date.formats.short", "2009-01-07")).toEqual("07 sty")
+    expect(I18n.l("date.formats.long", "2009-01-07")).toEqual("styczeń 07, 2009")
+  })
 
-  it("should translate the phrase using the t() function", function() {
-    expect(t("new")).toEqual("New")
+  it("localizes time strings", function() {
+    expect(I18n.l("time.formats.default", "2009-11-29 15:07:59")).toEqual("nie, 29 lis 2009 15:07:59 +0100")
+    expect(I18n.l("time.formats.short", "2009-01-07 09:12:35")).toEqual("07 sty 09:12")
+    expect(I18n.l("time.formats.long", "2009-11-29 15:07:59")).toEqual("listopad 29, 2009 15:07")
   })
 
 })

data/spec/javascripts/fixtures/translations.js

@@ -1,2 +1,98 @@
 I18n.locale = 'en'
-I18n.translations = { "new": "New" }
+I18n.default_locale = 'en'
+
+I18n.translations = {
+  en: {
+
+    hello: "Hello %{name}!",
+    world: "World",
+
+    page: {
+      footer: "Footer",
+      title: "Title",
+
+      intro: {
+        heading: "Heading"
+      }
+    }
+  },
+
+  pl: {
+    date: {
+      formats: {
+        "default": "%d-%m-%Y",
+        "short": "%d %b",
+        "long": "%B %d, %Y"
+      },
+      day_names: ["niedziela", "poniedziałek", "wtorek", "środa", "czwartek", "piątek", "sobota"],
+      abbr_day_names: ["nie", "pon", "wto", "śro", "czw", "pia", "sob"],
+      month_names: [null, "styczeń", "luty", "marzec", "kwiecień", "maj", "czerwiec", "lipiec", "sierpień", "wrzesień", "październik", "listopad", "grudzień"],
+      abbr_month_names: [null, "sty", "lut", "mar", "kwi", "maj", "cze", "lip", "sie", "wrz", "paź", "lis", "gru"],
+      order: ["day", "month", "year"]
+    },
+    time: {
+      formats: {
+        "default": "%a, %d %b %Y %H:%M:%S %z",
+        "short": "%d %b %H:%M",
+        "long": "%B %d, %Y %H:%M"
+      },
+      am: "przed południem",
+      pm: "po południu"
+    },
+    number: {
+      format: {
+        separator: ",",
+        delimiter: " ",
+        precision: 3,
+        significant: false,
+        strip_insignificant_zeros: false
+      },
+      currency: {
+        format: {
+          format: "%u %n",
+          unit: "PLN",
+          separator: ",",
+          delimiter: " ",
+          precision: 2,
+          significant: false,
+          strip_insignificant_zeros: true
+        }
+      },
+      percentage: {
+        format: {
+          delimiter: "",
+          separator: ",",
+          precision: 2
+        }
+      },
+      precision: {
+        format: {
+          delimiter: ""
+        }
+      },
+      human: {
+        format: {
+          delimiter: "",
+          precision: 3,
+          significant: true,
+          strip_insignificant_zeros: true
+        },
+        storage_units: {
+          format: "%n %u",
+          units: {
+            byte: {
+              one:   "bajt",
+              other: "bajty"
+            },
+            kb: "KB",
+            mb: "MB",
+            gb: "GB",
+            tb: "TB"
+          }
+        }
+      }
+    },
+
+    world: "Świat"
+  }
+}

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: exvo_globalize
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: 
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - "Pawe\xC5\x82 Go\xC5\x9Bcicki"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-09 00:00:00 +02:00
+date: 2011-09-14 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -389,7 +389,6 @@ files:
 - lib/generators/exvo_globalize/install_generator.rb
 - lib/generators/exvo_globalize/templates/migration.rb
 - lib/tasks/dump.rake
-- lib/tasks/jasmine.rake
 - spec/app.rb
 - spec/controllers/globalize_translations_controller_spec.rb
 - spec/exvo_globalize/caching_spec.rb

data/lib/tasks/jasmine.rake

@@ -1,8 +0,0 @@
-begin
-  require 'jasmine'
-  load 'jasmine/tasks/jasmine.rake'
-rescue LoadError
-  task :jasmine do
-    abort "Jasmine is not available. In order to run jasmine, you must: (sudo) gem install jasmine"
-  end
-end