twitter_cldr 1.0.0

data/spec/formatters/plurals/rules_spec.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec_helper")
+include TwitterCldr::Formatters::Plurals
+
+describe Rules do
+  describe "#get_resource" do
+    it "calls eval on the hash that gets returned, lambdas and all" do
+      result = Rules.send(:get_resource, :ru)
+      result.should include(:ru)
+      result[:ru].should include(:i18n)
+      result[:ru][:i18n].should include(:plural)
+      result[:ru][:i18n][:plural].should include(:keys)
+      result[:ru][:i18n][:plural][:keys].size.should == 4
+
+      result[:ru][:i18n][:plural].should include(:rule)
+      result[:ru][:i18n][:plural][:rule].should be_a(Proc)
+    end
+  end
+
+  describe "#rule_for" do
+    it "returns :one for English 1, :other for everything else" do
+      Rules.rule_for(1, :en).should == :one
+      [5, 9, 10, 20, 60, 99, 100, 103, 141].each do |num|
+        Rules.rule_for(num, :en).should == :other
+      end
+    end
+
+    it "returns the correct values for Russian rules" do
+      Rules.rule_for(1, :ru).should == :one
+      Rules.rule_for(2, :ru).should == :few
+      Rules.rule_for(3, :ru).should == :few
+      Rules.rule_for(4, :ru).should == :few
+      Rules.rule_for(5, :ru).should == :many
+      Rules.rule_for(6, :ru).should == :many
+      Rules.rule_for(7, :ru).should == :many
+      Rules.rule_for(8, :ru).should == :many
+      Rules.rule_for(9, :ru).should == :many
+      Rules.rule_for(10, :ru).should == :many
+      Rules.rule_for(11, :ru).should == :many
+
+      Rules.rule_for(101, :ru).should == :one
+      Rules.rule_for(102, :ru).should == :few
+      Rules.rule_for(111, :ru).should == :many
+    end
+
+    it "returns :other if there's an error" do
+      stub(Rules).get_resource { lambda { raise "Jelly beans" } }
+      Rules.rule_for(1, :en).should == :other
+      Rules.rule_for(1, :ru).should == :other
+    end
+  end
+
+  describe "#all_for" do
+    it "returns a list of all applicable rules for the given locale" do
+      Rules.all_for(:en).each { |rule| [:one, :other].should include(rule) }
+      Rules.all_for(:ru).each { |rule| [:one, :few, :many, :other].should include(rule) }
+    end
+
+    it "should return an empty array on error" do
+      stub(Rules).get_resource { lambda { raise "Jelly beans" } }
+      Rules.all_for(:en).should == []
+      Rules.all_for(:ru).should == []
+    end
+  end
+
+  describe "#all" do
+    it "gets rules for the default locale (usually supplied by FastGettext)" do
+      mock(TwitterCldr).get_locale { :ru }
+      rules = Rules.all
+      rules.size.should == 4
+      rules.each { |rule| [:one, :few, :many, :other].should include(rule) }
+    end
+  end
+end

data/spec/shared/currencies_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+include TwitterCldr::Shared
+
+TEST_COUNTRIES = ["Australia", "Thailand", "Russia", "China", "Japan", "Peru", "South Africa", "India", "South Korea", "United Kingdom"]
+TEST_CODES = ["AUD", "THB", "RUB", "CNY", "JPY", "PEN", "ZAR", "INR", "KRW", "GBP"]
+
+describe Currencies do
+  describe "#countries" do
+    it "should list all supported countries" do
+      countries = Currencies.countries
+      countries.size.should == 112
+      TEST_COUNTRIES.each { |country| countries.should include(country) }
+    end
+  end
+
+  describe "#currency_codes" do
+    it "should list all supported country codes" do
+      codes = Currencies.currency_codes
+      codes.size.should == 112
+      TEST_CODES.each { |code| codes.should include(code) }
+    end
+  end
+
+  describe "#for_country" do
+    it "should return all information for the given country" do
+      data = Currencies.for_country("Peru")
+      data.should be_a(Hash)
+
+      data.should include(:code)
+      data[:code].should == "PEN"
+      data.should include(:currency)
+      data[:currency].should == "Nuevo Sol"
+      data.should include(:symbol)
+      data[:symbol].should == "S/."
+
+      data.should_not include(:country)
+    end
+  end
+
+  describe "#for_code" do
+    it "should return all information for the given currency code" do
+      data = Currencies.for_code("PEN")
+      data.should be_a(Hash)
+
+      data.should include(:country)
+      data[:country].should == "Peru"
+      data.should include(:currency)
+      data[:currency].should == "Nuevo Sol"
+      data.should include(:symbol)
+      data[:symbol].should == "S/."
+
+      data.should_not include(:code)
+    end
+  end
+end

data/spec/shared/languages_spec.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+include TwitterCldr::Shared
+
+describe Languages do
+  describe "#translate_language" do
+    it "should translate a language from one locale to another" do
+      Languages.translate_language("Russian", :en, :es).should == "ruso"
+      Languages.translate_language("ruso", :es, :en).should == "Russian"
+      Languages.translate_language("Spanish", :en, :es).should == "español"
+      Languages.translate_language("ruso", :es, :ru).should == "русский"
+    end
+
+    it "should be capitalization agnostic" do
+      Languages.translate_language("russian", :en, :es).should == "ruso"
+      Languages.translate_language("RUSSIAN", :en, :es).should == "ruso"
+    end
+
+    it "defaults the destination language to English (or whatever FastGettext.locale is)" do
+      Languages.translate_language("Ruso", :es).should == "Russian"
+      Languages.translate_language("русский", :ru).should == "Russian"
+    end
+
+    it "defaults source and destination language to English if not given" do
+      Languages.translate_language("Russian").should == "Russian"
+      FastGettext.locale = :es
+      Languages.translate_language("Russian").should == "ruso"
+    end
+
+    it "successfully translates locale codes that are and are not in the CLDR using the locale map" do
+      Languages.translate_language("Russian", :en, :'zh-cn').should == "俄文"
+      Languages.translate_language("Russian", :en, :'zh').should == "俄文"
+    end
+
+    it "should return nil if no translation was found" do
+      Languages.translate_language("Russian", :en, :blarg).should == nil
+    end
+  end
+
+  describe "#from_code_for_locale" do
+    it "should return the language in the correct locale for the given locale code (i.e. es in English should be Spanish)" do
+      Languages.from_code_for_locale(:es, :en).should == "Spanish"
+      Languages.from_code_for_locale(:en, :es).should == "inglés"
+    end
+  end
+
+  describe "#from_code" do
+    it "should return the language in the default locale for the given locale code" do
+      Languages.from_code(:es).should == "Spanish"
+      Languages.from_code(:ru).should == "Russian"
+      FastGettext.locale = :es
+      Languages.from_code(:es).should == "español"
+    end
+  end
+
+  describe "#all_for" do
+    it "should return a hash of all languages for the given language code" do
+      langs = Languages.all_for(:es)
+      langs.should be_a(Hash)
+      langs[:ru].should == "ruso"
+    end
+
+    it "should return an empty hash for an invalid language" do
+      langs = Languages.all_for(:blarg)
+      langs.should == {}
+    end
+  end
+
+  describe "#all" do
+    it "should use the default language to get the language hash" do
+      langs = Languages.all
+      langs.should be_a(Hash)
+      langs[:ru].should == "Russian"
+      langs[:de].should == "German"
+
+      FastGettext.locale = :es
+      langs = Languages.all
+      langs.should be_a(Hash)
+      langs[:ru].should == "ruso"
+      langs[:de].should == "alemán"
+    end
+  end
+end

data/spec/shared/resources_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+include TwitterCldr::Shared
+
+describe Resources do
+  before(:each) do
+    @resource = Resources.new
+  end
+
+  describe "#resource_for" do
+    it "loads the requested resource from disk only once" do
+      # note that it should convert the string "de" into a symbol
+      mock(@resource).data_for(:de, "racehorse").once { "german racehorse resource" }
+
+      # do it twice - the second one shouldn't call data_for
+      @resource.resource_for("de", "racehorse").should == "german racehorse resource"
+      @resource.resource_for("de", "racehorse").should == "german racehorse resource"
+    end
+  end
+
+  describe "#data_for" do
+    it "loads the correct file for the given locale and resource" do
+      mock(YAML).load("data") { { "key" => "value" } }
+      mock(File).read(File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), "resources", "de", "racehorse.yml")) { "data" }
+      @resource.resource_for("de", "racehorse").should == { :key => "value" }
+    end
+  end
+
+  describe "#deep_symbolize_keys" do
+    it "should work with a regular hash" do
+      result = @resource.send(:deep_symbolize_keys, { "twitter" => "rocks", "my" => "socks" })
+      result.should == { :twitter => "rocks", :my => "socks"}
+    end
+
+    it "should work with nested hashes" do
+      result = @resource.send(:deep_symbolize_keys, { "twitter" => { "rocks" => "my socks" } })
+      result.should == { :twitter => { :rocks => "my socks" } }
+    end
+
+    it "should work with nested hashes and arrays" do
+      result = @resource.send(:deep_symbolize_keys, { "twitter" => { "rocks_my" => [{ "socks" => "and mind" }, { "hard" => "core" }] } })
+      result.should == { :twitter => { :rocks_my => [{ :socks => "and mind" }, { :hard => "core" }] } }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib twitter_cldr]))
+FIXTURE_DIR = File.expand_path(File.join(File.dirname(__FILE__), %w[fixtures]))
+
+class FastGettext
+  class << self
+    def locale
+      @@locale || :en
+    end
+
+    def locale=(value)
+      @@locale = value
+    end
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+
+  config.before(:each) do
+    FastGettext.locale = :en
+  end
+end
+
+def check_token_list(got, expected)
+  got.size.should == expected.size
+  expected.each_with_index do |exp_hash, index|
+    exp_hash.each_pair do |exp_key, exp_val|
+      got[index].send(exp_key).should == exp_val
+    end
+  end
+end

data/spec/tokenizers/base_spec.rb

@@ -0,0 +1,134 @@
+require File.join(File.dirname(File.dirname(__FILE__)), "spec_helper")
+include TwitterCldr::Tokenizers
+
+# normally, base can't be instantiated, so we have to patch it here
+module TwitterCldr
+  module Tokenizers
+    class Base
+      def init_resources; end
+    end
+  end
+end
+
+describe Base do
+  before(:each) do
+    @base = Base.new  # do NOT do this in production - must use subclass
+  end
+
+  it "creating a new base without a locale should default to English, with a locale should not" do
+    @base.locale.should == :en
+    Base.new(:locale => :de).locale.should == :de
+  end
+
+  # tokenize_pattern is supposed to take a pattern found in the YAML resource files and break it into placeholders and plaintext.
+  # Placeholders are delimited by single and double curly braces, plaintext is everything else.
+  describe "#tokenize_pattern" do
+    context "with double curlies (path names, essentially)" do
+      it "should work with a placeholder only" do
+        @base.send(:tokenize_pattern, "{{place}}").should == [{ :value => "{{place}}", :type => :placeholder }]
+      end
+
+      it "should work with two placeholders separated by a space" do
+        @base.send(:tokenize_pattern, "{{first}} {{second}}").should == [{ :value => "{{first}}", :type => :placeholder },
+                                                                         { :value => " ", :type => :plaintext },
+                                                                         { :value => "{{second}}", :type => :placeholder }]
+      end
+
+      it "should work when surrounded by plaintext" do
+        @base.send(:tokenize_pattern, "being {{totally}} awesome").should == [{ :value => "being ", :type => :plaintext },
+                                                                              { :value => "{{totally}}", :type => :placeholder },
+                                                                              { :value => " awesome", :type => :plaintext }]
+      end
+    end
+
+    context "with single curlies (indexes)" do
+      it "should work with a placeholder only" do
+        @base.send(:tokenize_pattern, "{1}").should == [{ :value => "{1}", :type => :placeholder }]
+      end
+
+      it "should work with two placeholders separated by a space" do
+        @base.send(:tokenize_pattern, "{0} {1}").should == [{ :value => "{0}", :type => :placeholder },
+                                                            { :value => " ", :type => :plaintext },
+                                                            { :value => "{1}", :type => :placeholder }]
+      end
+
+      it "should work when surrounded by plaintext" do
+        @base.send(:tokenize_pattern, "only {1} dragon").should == [{ :value => "only ", :type => :plaintext },
+                                                                    { :value => "{1}", :type => :placeholder },
+                                                                    { :value => " dragon", :type => :plaintext }]
+      end
+    end
+  end
+
+  describe "#choose_placeholder" do
+    before(:each) do
+      @placeholders = [{ :name => "wallace", :object => "man" }, { :name => "gromit", :object => "dog" }]
+    end
+
+    it "should choose the correct named placeholder" do
+      @base.send(:choose_placeholder, "{{wallace}}", @placeholders).should == "man"
+      @base.send(:choose_placeholder, "{{gromit}}", @placeholders).should == "dog"
+    end
+
+    it "should choose the correct placeholder by array index" do
+      @base.send(:choose_placeholder, "{0}", @placeholders).should == "man"
+      @base.send(:choose_placeholder, "{1}", @placeholders).should == "dog"
+    end
+  end
+
+  describe "#expand_pattern" do
+    it "recursively calls expand_pattern if a symbol (keypath) is given" do
+      mock(@base).traverse(:'another.path') { "found_me" }
+      mock(@base).pattern_for("found_me") { "pattern_text" }
+      mock.proxy(@base).expand_pattern("pattern_text", :fake_type)
+      mock.proxy(@base).expand_pattern(:'another.path', :fake_type)
+      @base.send(:expand_pattern, :'another.path', :fake_type).should == [{ :value => "pattern_text", :type => :plaintext }]
+    end
+
+    it "expands placeholders as necessary" do
+      placeholder_obj = Object.new
+      mock(placeholder_obj).tokens(:type => :man) { ["token1", "token2"] }
+      @base.placeholders = [{ :name => "wallace", :object => placeholder_obj }]
+      @base.send(:expand_pattern, "{{wallace}} rules", :man).should == ["token1", "token2", { :type => :plaintext, :value => " rules" }]
+    end
+
+    it "doesn't choke if the placeholder can't be found" do
+      @base.placeholders = [{ :name => "gromit", :object => "dog" }]
+      @base.send(:expand_pattern, "{{wallace}} rules", :man).should == [{ :type => :plaintext, :value => " rules" }]
+    end
+  end
+
+  describe "#traverse" do
+    before(:each) do
+      @tree = { :admiral => { :captain => { :commander => { :lieutenant => "Found Me!" } } } }
+    end
+
+    it "should find the correct value in the hash" do
+      @base.send(:traverse, :'admiral.captain.commander.lieutenant', @tree).should == "Found Me!"
+    end
+
+    it "shouldn't choke if the path doesn't exist" do
+      @base.send(:traverse, :'admiral.captain.commander.lieutenant.ensign', @tree).should == nil
+    end
+  end
+
+  # Not to be confused with tokenize_pattern, which pulls out placeholders.  Tokenize_format actually splits a completely
+  # expanded format string into whatever parts are defined by the subclass's token type and token splitter regexes.
+  describe "#tokenize_format" do
+    it "assigns the right token types to the tokens" do
+      stub(@base).token_splitter_regex { /([abc])/ }
+      stub(@base).token_type_regexes { [{ :type => :a, :regex => /a/ },
+                                        { :type => :b, :regex => /b/ },
+                                        { :type => :c, :regex => /c/ },
+                                        { :type => :plaintext, :regex => // }] }
+      tokens = @base.send(:tokenize_format, "a b c")
+      tokens.size.should == 5
+
+      tokens[0].value.should == "a"; tokens[0].type.should == :a
+      tokens[1].value.should == " "; tokens[1].type.should == :plaintext
+      tokens[2].value.should == "b"; tokens[2].type.should == :b
+      tokens[3].value.should == " "; tokens[3].type.should == :plaintext
+      tokens[4].value.should == "c"; tokens[4].type.should == :c
+    end
+  end
+end

data/spec/tokenizers/calendars/date_tokenizer_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec_helper")
+include TwitterCldr::Tokenizers
+
+describe DateTokenizer do
+  describe "#tokens" do
+    it "should tokenize plaintext segments correctly (i.e. Spanish)" do
+      tokenizer = DateTokenizer.new(:locale => :es)
+      got = tokenizer.tokens(:type => :full)
+      expected = [{ :value => "EEEE", :type => :pattern },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "d", :type => :pattern },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "'de'", :type => :plaintext },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "MMMM", :type => :pattern },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "'de'", :type => :plaintext },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "y", :type => :pattern }]
+      check_token_list(got, expected)
+    end
+
+    it "should tokenize patterns with non-latin characters correctly (i.e. Japanese)" do
+      tokenizer = DateTokenizer.new(:locale => :ja)
+      got = tokenizer.tokens(:type => :full)
+      expected  = [{ :value => "y", :type => :pattern },
+                   { :value => "年", :type => :plaintext },
+                   { :value => "M", :type => :pattern },
+                   { :value => "月", :type => :plaintext },
+                   { :value => "d", :type => :pattern },
+                   { :value => "日", :type => :plaintext },
+                   { :value => "EEEE", :type => :pattern }]
+      check_token_list(got, expected)
+    end
+  end
+end

data/spec/tokenizers/calendars/datetime_tokenizer_spec.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec_helper")
+include TwitterCldr::Tokenizers
+
+describe DateTimeTokenizer do
+  describe "#initialize" do
+    it "chooses gregorian as the calendar type if none is specified" do
+      DateTimeTokenizer.new.calendar_type.should == :gregorian
+      DateTimeTokenizer.new(:calendar_type => :julian).calendar_type.should == :julian
+    end
+
+    it "initializes individual date and time placeholder tokenizers" do
+      placeholders = DateTimeTokenizer.new.placeholders
+      placeholders[0][:name].should == :date
+      placeholders[0][:object].should be_a(DateTokenizer)
+      placeholders[1][:name].should == :time
+      placeholders[1][:object].should be_a(TimeTokenizer)
+    end
+  end
+
+  describe "#tokens" do
+    it "should choose the default date time path if no other type is specified" do
+      tokenizer = DateTimeTokenizer.new
+      mock.proxy(tokenizer.paths)[:default]
+      tokenizer.tokens
+    end
+
+    it "should expand date and time placeholders and return the correct list of tokens" do
+      tokenizer = DateTimeTokenizer.new(:locale => :es)
+      got = tokenizer.tokens(:type => :full)
+      expected = [{ :value => "HH", :type => :pattern },
+                  { :value => ":", :type => :plaintext },
+                  { :value => "mm", :type => :pattern },
+                  { :value => ":", :type => :plaintext },
+                  { :value => "ss", :type => :pattern },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "zzzz", :type => :pattern },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "EEEE", :type => :pattern },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "d", :type => :pattern },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "'de'", :type => :plaintext },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "MMMM", :type => :pattern },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "'de'", :type => :plaintext },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "y", :type => :pattern }]
+      check_token_list(got, expected)
+    end
+  end
+end

data/spec/tokenizers/calendars/time_tokenizer_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec_helper")
+include TwitterCldr::Tokenizers
+
+describe DateTokenizer do
+  describe "#tokens" do
+    it "should tokenize a time string correctly (i.e. German)" do
+      tokenizer = TimeTokenizer.new(:locale => :de)
+      got = tokenizer.tokens(:type => :full)
+      expected = [{ :value => "HH", :type => :pattern },
+                  { :value => ":", :type => :plaintext },
+                  { :value => "mm", :type => :pattern },
+                  { :value => ":", :type => :plaintext },
+                  { :value => "ss", :type => :pattern },
+                  { :value => " ", :type => :plaintext },
+                  { :value => "zzzz", :type => :pattern }]
+      check_token_list(got, expected)
+    end
+
+    it "should tokenize patterns with non-latin characters correctly (i.e. Korean)" do
+      tokenizer = TimeTokenizer.new(:locale => :ko)
+      got = tokenizer.tokens(:type => :full)
+      expected  = [{ :value => "a", :type => :pattern },
+                   { :value => " ", :type => :plaintext },
+                   { :value => "hh", :type => :pattern },
+                   { :value => "시 ", :type => :plaintext },
+                   { :value => "mm", :type => :pattern },
+                   { :value => "분 ", :type => :plaintext },
+                   { :value => "ss", :type => :pattern },
+                   { :value => "초 ", :type => :plaintext },
+                   { :value => "zzzz", :type => :pattern }]
+      check_token_list(got, expected)
+    end
+  end
+end

data/spec/tokenizers/key_path_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(File.dirname(__FILE__)), "spec_helper")
+include TwitterCldr::Tokenizers
+
+describe KeyPath do
+  describe "#dirname" do
+    it "should strip off the last element" do
+      KeyPath.dirname("castle.in.the.sky").should == "castle.in.the"
+    end
+
+    it "shouldn't choke if given an empty string" do
+      KeyPath.dirname("").should == ""
+    end
+  end
+
+  describe "#join" do
+    it "joins two args with two dots" do
+      KeyPath.join("seahawks.", ".rule").should == "seahawks.rule"
+    end
+
+    it "joins two args with one dot at the end of the first" do
+      KeyPath.join("seahawks.", "rule").should == "seahawks.rule"
+    end
+
+    it "joins two args with one dot at the beginning of the second" do
+      KeyPath.join("seahawks", ".rule").should == "seahawks.rule"
+    end
+
+    it "joins two args with no dots" do
+      KeyPath.join("seahawks", "rule").should == "seahawks.rule"
+    end
+  end
+
+  describe "#split_path" do
+    it "should split the path by dots" do
+      KeyPath.split_path("rain.in.spain").should == ["rain", "in", "spain"]
+    end
+  end
+
+  describe "#join_path" do
+    it "should join the path with dots" do
+      KeyPath.join_path(["rain", "in", "spain"]).should == "rain.in.spain"
+    end
+  end
+end

data/spec/tokenizers/numbers/number_tokenizer_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec_helper")
+include TwitterCldr::Tokenizers
+
+describe NumberTokenizer do
+  describe "#initialize" do
+    it "chooses decimal as the default type if no other type is specified" do
+      NumberTokenizer.new.type.should == :decimal
+      NumberTokenizer.new(:type => :percent).type.should == :percent
+    end
+  end
+
+  describe "#full_path_for" do
+    it "should fill in the type and return the full path to the requested format" do
+      NumberTokenizer.new.send(:full_path_for, :default).should == "numbers.formats.decimal.patterns.default"
+    end
+  end
+
+  describe "#tokens" do
+    it "ensures that positive and negative entries are created (as necessary)" do
+      tokenizer = NumberTokenizer.new(:locale => :tr)
+      tokenizer.tokens
+      root = tokenizer.resource[:numbers][:formats][:decimal][:patterns]
+      root.should include(:positive)
+      root.should include(:negative)
+    end
+
+    it "gets tokens for a latin language (i.e. Portuguese)" do
+      tokenizer = NumberTokenizer.new(:locale => :pt)
+      got = tokenizer.tokens
+      expected = [{ :value => "", :type => :pattern },
+                  { :value => "#,##0.###", :type => :pattern }]
+      check_token_list(got, expected)
+    end
+
+    it "gets tokens for a non-latin language (i.e. Russian)" do
+      tokenizer = NumberTokenizer.new(:locale => :ru)
+      got = tokenizer.tokens
+      expected = [{ :value => "", :type => :pattern },
+                  { :value => "#,##0.###", :type => :pattern }]
+      check_token_list(got, expected)
+    end
+
+    it "correctly parses suffixes (i.e. Russian currency)" do
+      tokenizer = NumberTokenizer.new(:locale => :ru, :type => :currency)
+      got = tokenizer.tokens
+      expected = [{ :value => "", :type => :pattern },
+                  { :value => "#,##0.00", :type => :pattern },
+                  { :value => " ¤", :type => :pattern }]
+      check_token_list(got, expected)
+    end
+
+    it "correctly parses prefixes (i.e. Italian currency)" do
+      tokenizer = NumberTokenizer.new(:locale => :it, :type => :currency)
+      got = tokenizer.tokens
+      expected = [{ :value => "¤ ", :type => :pattern },
+                  { :value => "#,##0.00", :type => :pattern }]
+      check_token_list(got, expected)
+    end
+  end
+end

data/spec/tokenizers/token_spec.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(File.dirname(__FILE__)), "spec_helper")
+include TwitterCldr::Tokenizers
+
+describe Token do
+  describe "#initialize" do
+    it "should set instance variables passed in the options hash" do
+      token = Token.new(:type => "my_type", :value => "my_value")
+      token.type.should == "my_type"
+      token.value.should == "my_value"
+    end
+  end
+
+  describe "#to_s" do
+    it "should return the token's value" do
+      Token.new(:value => "my_value").to_s.should == "my_value"
+    end
+  end
+end