twitter_cldr_js 1.0.0

data/lib/twitter_cldr/js/compiler.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Js
+    class Compiler
+      attr_reader :locales
+
+      def initialize(options = {})
+        @locales = options[:locales] || TwitterCldr.supported_locales
+        @features = options[:features] || renderers.keys
+      end
+
+      def compile_each(options = {})
+        options[:minify] = true unless options.include?(:minify)
+
+        @locales.each do |locale|
+          contents = ""
+
+          @features.each do |feature|
+            renderer_const = renderers[feature]
+            contents << renderer_const.new(:locale => locale).render if renderer_const
+          end
+
+          bundle = TwitterCldr::Js::Renderers::Bundle.new
+          bundle[:contents] = contents
+          result = CoffeeScript.compile(bundle.render, :bare => true)
+          result = Uglifier.compile(result) if options[:minify]
+
+          yield result, TwitterCldr.twitter_locale(locale)
+        end
+      end
+
+      private
+
+      def renderers
+        @renderers ||= {
+          :plural_rules => TwitterCldr::Js::Renderers::PluralRules::PluralRulesRenderer,
+          :timespan => TwitterCldr::Js::Renderers::Calendars::TimespanRenderer,
+          :datetime => TwitterCldr::Js::Renderers::Calendars::DateTimeRenderer,
+          :numbers => TwitterCldr::Js::Renderers::Numbers::NumbersRenderer,
+          :currencies => TwitterCldr::Js::Renderers::Shared::CurrenciesRenderer
+        }
+      end
+    end
+  end
+end

data/lib/twitter_cldr/js/mustache/bundle.coffee

@@ -0,0 +1,15 @@
+###
+// Copyright 2012 Twitter, Inc
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// TwitterCLDR (JavaScript) v{{version}}
+// Authors:     Cameron Dutro [@camertron]
+                Kirill Lashuk [@KL_7]
+                portions by Sven Fuchs [@svenfuchs]
+// Homepage:    https://twitter.com
+// Description: Provides date, time, number, and list formatting functionality for various Twitter-supported locales in Javascript.
+###
+
+TwitterCldr = {}
+{{{contents}}}
+exports[key] = obj for key, obj of TwitterCldr if exports?  # for node

data/lib/twitter_cldr/js/mustache/calendars/datetime.coffee

@@ -0,0 +1,240 @@
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+TwitterCldr.DateTimeFormatter = class DateTimeFormatter
+	constructor: ->
+		@tokens = `{{{tokens}}}`
+		@calendar = `{{{calendar}}}`
+		@weekday_keys = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"]
+		@methods = # ignoring u, l, g, j, A
+			'G': 'era'
+			'y': 'year'
+			'Y': 'year_of_week_of_year'
+			'Q': 'quarter'
+			'q': 'quarter_stand_alone'
+			'M': 'month'
+			'L': 'month_stand_alone'
+			'w': 'week_of_year'
+			'W': 'week_of_month'
+			'd': 'day'
+			'D': 'day_of_month'
+			'F': 'day_of_week_in_month'
+			'E': 'weekday'
+			'e': 'weekday_local'
+			'c': 'weekday_local_stand_alone'
+			'a': 'period'
+			'h': 'hour'
+			'H': 'hour'
+			'K': 'hour'
+			'k': 'hour'
+			'm': 'minute'
+			's': 'second'
+			'S': 'second_fraction'
+			'z': 'timezone'
+			'Z': 'timezone'
+			'v': 'timezone_generic_non_location'
+			'V': 'timezone_metazone'
+
+	format: (obj, options) ->
+		format_token = (token) =>
+			result = ""
+
+			switch token.type
+				when "pattern"
+					return this.result_for_token(token, obj)
+				else
+					if token.value.length > 0 && token.value[0] == "'" && token.value[token.value.length - 1] == "'"
+						return token.value.substring(1, token.value.length - 1)
+					else
+					 	return token.value
+
+		tokens = this.get_tokens(obj, options)
+		return (format_token(token) for token in tokens).join("")
+
+	get_tokens: (obj, options) ->
+		return @tokens[options.format || "date_time"][options.type || "default"]
+
+	result_for_token: (token, date) ->
+		return this[@methods[token.value[0]]](date, token.value, token.value.length)
+
+	era: (date, pattern, length) ->
+		switch length
+      when 1, 2, 3
+        choices = @calendar["eras"]["abbr"]
+      else
+        choices = @calendar["eras"]["name"]
+
+    index = if (date.getFullYear() < 0) then 0 else 1
+    return choices[index]
+
+	year: (date, pattern, length) ->
+		year = date.getFullYear().toString()
+
+		if length == 2
+			if year.length != 1
+				year = year.slice(-2)
+
+		if length > 1
+			year = ("0000" + year).slice(-length)
+
+		return year
+
+	year_of_week_of_year: (date, pattern, length) ->
+		throw 'not implemented'
+
+	day_of_week_in_month: (date, pattern, length) -> # e.g. 2nd Wed in July
+		throw 'not implemented'
+
+	quarter: (date, pattern, length) ->
+		# the bitwise OR is used here to truncate the decimal produced by the / 3
+		quarter = ((date.getMonth() / 3) | 0) + 1
+
+		switch length
+			when 1
+				return quarter.toString()
+			when 2
+				return ("0000" + quarter.toString()).slice(-length)
+			when 3
+				return @calendar.quarters.format.abbreviated[quarter]
+			when 4
+				return @calendar.quarters.format.wide[quarter]
+
+	quarter_stand_alone: (date, pattern, length) ->
+		quarter = (date.getMonth() - 1) / 3 + 1
+
+		switch length
+			when 1
+				return quarter.toString()
+			when 2
+				return ("0000" + quarter.toString()).slice(-length)
+			when 3
+				throw 'not yet implemented (requires cldr\'s "multiple inheritance")'
+			when 4
+				throw 'not yet implemented (requires cldr\'s "multiple inheritance")'
+			when 5
+				return @calendar.quarters['stand-alone'].narrow[quarter]
+
+	month: (date, pattern, length) ->
+		month_str = (date.getMonth() + 1).toString()
+
+		switch length
+			when 1
+				return month_str
+			when 2
+				return ("0000" + month_str).slice(-length)
+			when 3
+				return @calendar.months.format.abbreviated[month_str]
+			when 4
+				return @calendar.months.format.wide[month_str]
+			when 5
+				throw 'not yet implemented (requires cldr\'s "multiple inheritance")'
+			else
+				throw "Unknown date format"
+
+	month_stand_alone: (date, pattern, length) ->
+		switch length
+			when 1
+				return date.getMonth().toString()
+			when 2
+				return ("0000" + date.getMonth().toString()).slice(-length)
+			when 3
+				throw 'not yet implemented (requires cldr\'s "multiple inheritance")'
+			when 4
+				throw 'not yet implemented (requires cldr\'s "multiple inheritance")'
+			when 5
+				return @calendar.months['stand-alone'].narrow[date.month]
+			else
+				throw "Unknown date format"
+
+	day: (date, pattern, length) ->
+		switch length
+			when 1
+				return date.getDate().toString()
+			when 2
+				return ("0000" + date.getDate().toString()).slice(-length)
+
+	weekday: (date, pattern, length) ->
+		key = @weekday_keys[date.getDay()]
+
+		switch length
+			when 1, 2, 3
+				return @calendar.days.format.abbreviated[key]
+			when 4
+				return @calendar.days.format.wide[key]
+			when 5
+				return @calendar.days['stand-alone'].narrow[key]
+
+	weekday_local: (date, pattern, length) ->
+		# "Like E except adds a numeric value depending on the local starting day of the week"
+    # CLDR does not contain data as to which day is the first day of the week, so we will assume Monday (Ruby default)
+		switch length
+      when 1, 2
+        day = date.getDay()
+        return (if day == 0 then "7" else day.toString())
+      else
+        return this.weekday(date, pattern, length)
+
+	weekday_local_stand_alone: (date, pattern, length) ->
+		switch length
+      when 1
+        return this.weekday_local(date, pattern, length)
+      else
+        return this.weekday(date, pattern, length)
+
+	period: (time, pattern, length) ->
+		if time.getHours() > 11
+			return @calendar.periods.format.wide["pm"]
+		else
+			return @calendar.periods.format.wide["am"]
+
+	hour: (time, pattern, length) ->
+		hour = time.getHours()
+
+		switch pattern[0]
+			when 'h'
+				if hour > 12
+					hour = hour - 12
+				else if hour == 0
+					hour = 12
+			when 'K'
+				if hour > 11
+					hour = hour - 12
+			when 'k'
+				if hour == 0
+					hour = 24
+
+		if length == 1
+			return hour.toString()
+		else
+			return ("000000" + hour.toString()).slice(-length)
+
+	minute: (time, pattern, length) ->
+		if length == 1
+			return time.getMinutes().toString()
+		else
+			return ("000000" + time.getMinutes().toString()).slice(-length)
+
+	second: (time, pattern, length) ->
+		if length == 1
+			return time.getSeconds().toString()
+		else
+			return ("000000" + time.getSeconds().toString()).slice(-length)
+
+	second_fraction: (time, pattern, length) ->
+		if length > 6
+			throw 'can not use the S format with more than 6 digits'
+
+		return ("000000" + Math.round(Math.pow(time.getMilliseconds() * 100.0, 6 - length)).toString()).slice(-length)
+
+	timezone: (time, pattern, length) ->
+		hours = ("00" + (time.getTimezoneOffset() / 60).toString()).slice(-2)
+		minutes = ("00" + (time.getTimezoneOffset() % 60).toString()).slice(-2)
+
+		switch length
+			when 1, 2, 3
+				return "-" + hours + ":" + minutes
+			else
+				return "UTC -" + hours + ":" + minutes
+
+	timezone_generic_non_location: (time, pattern, length) ->
+		throw 'not yet implemented (requires timezone translation data")'

data/lib/twitter_cldr/js/mustache/calendars/timespan.coffee

@@ -0,0 +1,52 @@
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+TwitterCldr.TimespanFormatter = class TimespanFormatter
+  constructor: ->
+    @default_type = "default"
+    @tokens = `{{{tokens}}}`
+    @time_in_seconds = {
+      "second": 1,
+      "minute": 60,
+      "hour":   3600,
+      "day":    86400,
+      "week":   604800,
+      "month":  2629743.83,
+      "year":   31556926
+    }
+
+  format: (seconds, options = {}) ->
+    options["direction"] ||= (if seconds < 0 then "ago" else "until")
+    options["unit"] = this.calculate_unit(Math.abs(seconds)) if options["unit"] is null or options["unit"] is undefined
+    options["type"] ||= @default_type
+    options["number"] = this.calculate_time(Math.abs(seconds), options["unit"])
+    number = this.calculate_time(Math.abs(seconds), options["unit"])
+    options["rule"] = TwitterCldr.PluralRules.rule_for(number)
+
+    strings = (token.value for token in @tokens[options["direction"]][options["unit"]][options["type"]][options["rule"]])
+    strings.join("").replace(/\{[0-9]\}/, number.toString())
+
+  calculate_unit: (seconds) ->
+    if seconds < 30
+      "second"
+    else if seconds < 2670
+      "minute"
+    else if seconds < 86369
+      "hour"
+    else if seconds < 604800
+      "day"
+    else if seconds < 2591969
+      "week"
+    else if seconds < 31556926
+      "month"
+    else
+      "year"
+
+  # 0 <-> 29 secs                                                   # => seconds
+  # 30 secs <-> 44 mins, 29 secs                                    # => minutes
+  # 44 mins, 30 secs <-> 23 hrs, 59 mins, 29 secs                   # => hours
+  # 23 hrs, 59 mins, 29 secs <-> 29 days, 23 hrs, 59 mins, 29 secs  # => days
+  # 29 days, 23 hrs, 59 mins, 29 secs <-> 1 yr minus 1 sec          # => months
+  # 1 yr <-> max time or date                                       # => years
+  calculate_time: (seconds, unit) ->
+    Math.round(seconds / @time_in_seconds[unit])

data/lib/twitter_cldr/js/mustache/numbers/numbers.coffee

@@ -0,0 +1,179 @@
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+TwitterCldr.NumberFormatter = class NumberFormatter
+	constructor: ->
+    @all_tokens = `{{{tokens}}}`
+    @tokens = []
+    @symbols = `{{{symbols}}}`
+
+    @default_symbols = 
+      'group': ','
+      'decimal': '.'
+      'plus_sign': '+'
+      'minus_sign': '-'
+
+  format: (number, options = {}) ->
+    opts = this.default_format_options_for(number)
+
+    for key, val of options
+      opts[key] = if options[key]? then options[key] else opts[key]
+
+    [prefix, suffix, integer_format, fraction_format] = this.partition_tokens(this.get_tokens(number, opts))
+    [int, fraction] = this.parse_number(number, opts)
+    result = integer_format.apply(parseFloat(int), opts)
+    result += fraction_format.apply(fraction, opts) if fraction
+    sign = if number < 0 && prefix != "-" then @symbols.minus_sign || @default_symbols.minus_sign else ""
+    "#{prefix}#{result}#{suffix}"
+
+  partition_tokens: (tokens) ->
+    [tokens[0] || "",
+     tokens[2] || "",
+     new IntegerHelper(tokens[1], @symbols),
+     new FractionHelper(tokens[1], @symbols)]
+
+  parse_number: (number, options = {}) ->
+    if options.precision?
+      precision = options.precision
+    else
+      precision = this.precision_from(number)
+
+    number = this.round_to(number, precision)
+    Math.abs(number).toFixed(precision).split(".")
+
+  precision_from: (num) ->
+    parts = num.toString().split(".")
+    if parts.length == 2 then parts[1].length else 0
+
+  round_to: (number, precision) ->
+    factor = Math.pow(10, precision)
+    Math.round(number * factor) / factor
+
+  get_tokens: ->
+    throw "get_tokens() not implemented - use a derived class like PercentFormatter."
+
+TwitterCldr.PercentFormatter = class PercentFormatter extends NumberFormatter
+  constructor: (options = {}) ->
+    @default_percent_sign = "%"
+    super
+
+  format: (number, options = {}) ->
+    super(number, options).replace('¤', @symbols.percent_sign || @default_percent_sign)
+
+  default_format_options_for: (number) ->
+    precision: 0
+
+  get_tokens: (number, options) ->
+    if number < 0 then @all_tokens.percent.negative else @all_tokens.percent.positive
+
+TwitterCldr.DecimalFormatter = class DecimalFormatter extends NumberFormatter
+  format: (number, options = {}) ->
+    try
+      super(number, options)
+    catch error
+      number
+
+  default_format_options_for: (number) ->
+    precision: this.precision_from(number)
+
+  get_tokens: (number, options = {}) ->
+    if number < 0 then @all_tokens.decimal.negative else @all_tokens.decimal.positive
+
+TwitterCldr.CurrencyFormatter = class CurrencyFormatter extends NumberFormatter
+  constructor: (options = {}) ->
+    @default_currency_symbol = "$"
+    @default_precision = 2
+    super
+
+  format: (number, options = {}) ->
+    if options.currency
+      if TwitterCldr.Currencies?
+        currency = TwitterCldr.Currencies.for_code(options.currency)
+        currency ||= TwitterCldr.Currencies.for_country(options.currency)
+        currency ||= symbol: options.currency
+      else
+        currency = symbol: options.currency
+    else
+      currency = symbol: @default_currency_symbol
+
+    super(number, options).replace('¤', currency.symbol)
+
+  default_format_options_for: (number) ->
+    precision = this.precision_from(number)
+    if precision == 0 then precision = @default_precision
+    precision: precision
+
+  get_tokens: (number, options = {}) ->
+    if number < 0 then @all_tokens.currency.negative else @all_tokens.currency.positive
+
+TwitterCldr.NumberFormatter.BaseHelper = class BaseHelper
+  interpolate: (string, value, orientation = "right") ->
+    value = value.toString()
+    length = value.length
+    start = if orientation == "left" then 0 else -length
+    string = (("#" for i in [0...length]).join("") + string).slice(-length) if string.length < length
+
+    if start < 0
+      string = string[0...(start + string.length)] + value
+    else
+      string = string[0...start] + value + string[(length)..-1]
+
+    string.replace(/#/g, "")
+
+TwitterCldr.NumberFormatter.IntegerHelper = class IntegerHelper extends BaseHelper
+  constructor: (token, symbols = {}) ->
+    format     = token.split('.')[0]
+    @format    = this.prepare_format(format, symbols)
+    @groups    = this.parse_groups(format)
+    @separator = symbols.group || ','
+
+  apply: (number, options = {}) ->
+    this.format_groups(this.interpolate(@format, parseInt(number)))
+
+  format_groups: (string) ->
+    return string if @groups.length == 0
+    tokens = []
+
+    cur_token = this.chop_group(string, @groups[0])
+    tokens.push(cur_token)
+    string = string[0...(string.length - cur_token.length)] if cur_token
+
+    while string.length > @groups[@groups.length - 1]
+      cur_token = this.chop_group(string, @groups[@groups.length - 1])
+      tokens.push(cur_token)
+      string = string[0...(string.length - cur_token.length)] if cur_token
+
+    tokens.push(string)
+    (token for token in tokens when token != null).reverse().join(@separator)
+
+  parse_groups: (format) ->
+    return [] unless index = format.lastIndexOf(',')
+    rest = format[0...index]
+    widths = [format.length - index - 1]
+    widths.push(rest.length - rest.lastIndexOf(',') - 1) if rest.lastIndexOf(',') > -1
+    widths = (width for width in widths when width != null)  # compact
+    widths.reverse()  # uniq
+    (widths[index] for index in [0...widths.length] when widths.indexOf(widths[index], index + 1) == -1).reverse()
+
+  chop_group: (string, size) ->
+    if string.length > size then string[-size..-1] else null
+
+  prepare_format: (format, symbols) ->
+    format.replace(",", "").replace("+", symbols.plus_sign).replace("-", symbols.minus_sign)
+
+TwitterCldr.NumberFormatter.FractionHelper = class FractionHelper extends BaseHelper
+  constructor: (token, symbols = {}) ->
+    @format = if token then token.split('.').pop() else ""
+    @decimal = symbols.decimal || "."
+    @precision = @format.length
+
+  apply: (fraction, options = {}) ->
+    precision = if options.precision? then options.precision else @precision
+    if precision > 0
+      @decimal + this.interpolate(this.format_for(options), fraction, "left")
+    else
+      ""
+
+  format_for: (options) ->
+    precision = if options.precision? then options.precision else @precision
+    if precision then ("0" for i in [0...precision]).join("") else @format

data/lib/twitter_cldr/js/mustache/plurals/rules.coffee

@@ -0,0 +1,14 @@
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+TwitterCldr.PluralRules = class PluralRules
+  @rules = `{{{rules}}}`
+
+  @all: ->
+    return @rules.keys
+
+  @rule_for: (number) ->
+    try
+      return @rules.rule(number)
+    catch error
+      return "other"

data/lib/twitter_cldr/js/mustache/shared/currencies.coffee

@@ -0,0 +1,27 @@
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+TwitterCldr.Currencies = class Currencies
+  @currencies = `{{{currencies}}}`
+
+  @countries: ->
+    @names ||= (country_name for country_name, data of @currencies)
+
+  @currency_codes: ->
+    @codes ||= (data.code for country_name, data of @currencies)
+
+  @for_country: (country_name) ->
+    @currencies[country_name]
+
+  @for_code: (currency_code) ->
+    final = null
+    for country_name, data of @currencies
+      if data.code == currency_code
+        final =
+          country: country_name
+          code: data.code
+          symbol: data.symbol
+          currency: data.currency
+        break
+
+    final

data/lib/twitter_cldr/js/renderers/base.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Js
+    module Renderers
+      class Base < Mustache
+
+        def initialize(options = {})
+          @locale = options[:locale]
+        end
+
+      end
+    end
+  end
+end

data/lib/twitter_cldr/js/renderers/bundle.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Js
+    module Renderers
+      class Bundle < Mustache
+        self.template_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "mustache/bundle.coffee"))
+
+        def version
+          TwitterCldr::VERSION
+        end
+      end
+    end
+  end
+end

data/lib/twitter_cldr/js/renderers/calendars/datetime_renderer.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Js
+    module Renderers
+      module Calendars
+        class DateTimeRenderer < TwitterCldr::Js::Renderers::Base
+          self.template_file = File.expand_path(File.join(File.dirname(__FILE__), "../..", "mustache/calendars/datetime.coffee"))
+
+          def tokens
+            tokens = {}
+            { :date_time => TwitterCldr::Tokenizers::DateTimeTokenizer,
+              :time => TwitterCldr::Tokenizers::TimeTokenizer,
+              :date => TwitterCldr::Tokenizers::DateTokenizer }.each_pair do |name, const|
+              tokenizer = const.new(:locale => @locale)
+              tokens[name] = const::VALID_TYPES.inject({}) do |ret, type|
+                ret[type] = tokenizer.tokens(:type => type).map(&:to_hash)
+                ret
+              end
+            end
+            tokens.to_json
+          end
+
+          def calendar
+            TwitterCldr::Tokenizers::DateTimeTokenizer.new(:locale => @locale).calendar.to_json
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twitter_cldr/js/renderers/calendars/timespan_renderer.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+include TwitterCldr::Tokenizers
+include TwitterCldr::Formatters
+
+module TwitterCldr
+  module Js
+    module Renderers
+      module Calendars
+
+        class TimespanRenderer < TwitterCldr::Js::Renderers::Base
+          self.template_file = File.expand_path(File.join(File.dirname(__FILE__), "../..", "mustache/calendars/timespan.coffee"))
+
+          def tokens
+            tokenizer = TimespanTokenizer.new(:locale => @locale)
+            [:ago, :until, :none].inject({}) do |final, direction|
+              final[direction] = TimespanTokenizer::VALID_UNITS.inject({}) do |unit_hash, unit|
+                unit_hash[unit] = tokenizer.all_types_for(unit, direction).inject({}) do |type_hash, type|
+                  type_hash[type] = Plurals::Rules.all_for(@locale).inject({}) do |rule_hash, rule|
+                    rule_hash[rule] = tokenizer.tokens(:direction => direction, :unit => unit, :rule => rule, :type => type)
+                    rule_hash
+                  end
+                  type_hash
+                end
+                unit_hash
+              end
+              final
+            end.to_json
+          end
+
+        end
+
+      end
+    end
+  end
+end