twitter_cldr 1.5.0 → 1.6.0

data/js/lib/mustache/bundle.coffee

@@ -0,0 +1,14 @@
+###
+// 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}}}

data/js/lib/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/js/lib/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/js/lib/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/js/lib/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/js/lib/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/js/lib/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/js/lib/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

data/js/lib/renderers/plurals/rules/plural_rules_compiler.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'ruby_parser'
+
+module TwitterCldr
+  module Js
+    module Renderers
+      module PluralRules
+
+        class PluralRulesCompiler
+
+          class << self
+            def rule_to_js(rule_code)
+              tree = RubyParser.new.parse(rule_code).to_a
+              "function(n) { return #{statement_list(tree)} }"
+            end
+
+            protected
+
+            def statement_list(tree)
+              if tree.first == :block
+                tree[1..-1].map { |sub_tree| send(:"_#{sub_tree.first}", sub_tree) }.join(" ")
+              else
+                send(:"_#{tree.first}", tree)
+              end
+            end
+
+            def _if(tree)
+              result = "(function() { if (#{statement_list(tree[1])}) { return #{statement_list(tree[2])} }"
+              result << " else { return #{statement_list(tree[3])} }" if tree[3]
+              "#{result} })();"
+            end
+
+            def _lvar(tree)
+              tree.first.to_s
+            end
+
+            def _call(tree)
+              case tree[2]
+                when :==, :%, :<, :>  # special operators that actually resolve to method calls
+                  "#{statement_list(tree[1])} #{tree[2]} #{statement_list(tree[3])}"
+                when :include?
+                  "#{statement_list(tree[1])}.indexOf(#{statement_list(tree[3])}) >= 0"
+                else
+                  # this should be the only case where tree[1] might be nil (i.e. the method was not called on any object)
+                  call = tree[1] ? "#{statement_list(tree[1])}.#{tree[2]}" : tree[2].to_s
+                  arglist = statement_list(tree[3])
+                  arglist == "" ? call : "#{call}(#{arglist})"
+              end
+            end
+
+            def _arglist(tree)
+              tree[1..-1].map { |arg| statement_list(arg) }.join(", ")
+            end
+
+            def _lit(tree)
+              if tree[1].is_a?(Symbol) || tree[1].is_a?(String)
+                "\"#{tree[1]}\""
+              else
+                tree[1]
+              end
+            end
+
+            def _array(tree)
+              "[#{tree[1..-1].map { |arg| statement_list(arg) }.join(", ")}]"
+            end
+
+            def _not(tree)
+              "!(#{statement_list(tree[1])})"
+            end
+
+            def _and(tree)
+              "#{statement_list(tree[1])} && #{statement_list(tree[2])}"
+            end
+
+            def _or(tree)
+              "#{statement_list(tree[1])} || #{statement_list(tree[2])}"
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end