twitter_cldr 3.0.0.beta1 → 3.0.0

data/spec/collation/collation_spec.rb

@@ -6,7 +6,6 @@
 require 'spec_helper'
 
 require 'open-uri'
-require 'zip'
 
 include TwitterCldr::Collation
 
@@ -72,6 +71,8 @@ END
   def prepare_full_test
     return if File.file?(FULL_COLLATION_TEST_PATH)
 
+    require 'zip'
+
     print '  Downloading CollationAuxillary.zip ... '
     zip_file = Tempfile.new('CollationAuxillary.zip')
     zip_file.write(open(FULL_COLLATION_TEST_URL).read)

data/spec/collation/collator_spec.rb

@@ -84,8 +84,9 @@ describe Collator do
     let(:collation_elements) { [[39, 5, 5], [41, 5, 5], [43, 5, 5]] }
 
     before :each do
-      mock(TwitterCldr::Normalization::NFD).normalize_code_points(code_points) { code_points }
-      stub(TwitterCldr::Normalization::Base).combining_class_for { 0 }
+      any_instance_of(TwitterCldr::Shared::CodePoint) do |instance|
+        stub(instance).combining_class_for { 0 }
+      end
     end
 
     it 'returns collation elements for a string' do
@@ -214,7 +215,7 @@ describe Collator do
       mock(TrieLoader).load_default_trie { TrieBuilder.load_default_trie }
       mock(TrieLoader).load_tailored_trie.with_any_args { |*args| TrieBuilder.load_tailored_trie(*args) }
 
-      stub(TwitterCldr::Normalization::NFD).normalize_code_points { |code_points| code_points }
+      stub(TwitterCldr::Normalization).normalize_code_points { |code_points| code_points }
     end
 
     let(:locale)            { :some_locale }

data/spec/collation/tailoring_spec.rb

@@ -22,7 +22,7 @@ describe 'Unicode collation tailoring' do
         print "#{locale}\t-\t"
 
         lines = File.open(File.join(File.dirname(__FILE__), 'tailoring_tests', "#{locale}.txt")) do |file|
-          file.lines.map(&:strip)
+          file.each_line.map(&:strip)
         end
 
         active_tests  = lines.count(&method(:tailoring_test?))
@@ -49,7 +49,7 @@ describe 'Unicode collation tailoring' do
         else
           failures_info = "#{failures.size} failures: #{failures.inspect}"
           puts failures_info
-          # failures.should(be_empty, "#{locale} - #{failures_info}")  # currently breaks build for Hebrew (he).  Probably should look into this.
+          failures.should(be_empty, "#{locale} - #{failures_info}")
         end
       end
     end

data/spec/collation/tailoring_tests/he.txt

@@ -1,4 +1,7 @@
-# Pending: failures identical to ICU.
+# Pending:
+#   - Failure on line 53 is caused by script reordering (http://site.icu-project.org/design/collation/script-reordering)
+#     that is applied to Hebrew as well as to a few other locales, but is not supported by TwitterCLDR yet.
+#   - Other failures are identical to ICU.
 
 xֽ
 x‎
@@ -48,7 +51,7 @@ X.
 x.x
 x־
 X־
-x־x
+// x־x
 x׳
 X׳
 x׳x

data/spec/{tokenizers/calendars → data_readers}/additional_date_format_selector_spec.rb

@@ -5,7 +5,7 @@
 
 require 'spec_helper'
 
-include TwitterCldr::Tokenizers
+include TwitterCldr::DataReaders
 
 describe AdditionalDateFormatSelector do
   let(:selector) do
@@ -90,16 +90,16 @@ describe AdditionalDateFormatSelector do
 
   describe "#find_closest" do
     it "returns an exact match if it exists" do
-      selector.find_closest("h").should == "h"
-      selector.find_closest("MMMd").should == "MMMd"
-      selector.find_closest("Hms").should == "Hms"
-      selector.find_closest("yQQQQ").should == "yQQQQ"
+      selector.find_closest("h").should == selector.pattern_hash[:h]
+      selector.find_closest("MMMd").should == selector.pattern_hash[:MMMd]
+      selector.find_closest("Hms").should == selector.pattern_hash[:Hms]
+      selector.find_closest("yQQQQ").should == selector.pattern_hash[:yQQQQ]
     end
 
     it "returns the next closest match (lowest score) if an exact match can't be found" do
-      selector.find_closest("MMMMd").should == "MMMd"
-      selector.find_closest("mHs").should == "Hms"
-      selector.find_closest("Med").should == "MEd"
+      selector.find_closest("MMMMd").should == selector.pattern_hash[:MMMd]
+      selector.find_closest("mHs").should == selector.pattern_hash[:Hms]
+      selector.find_closest("Med").should == selector.pattern_hash[:MEd]
     end
 
     it "returns nil if an empty pattern is given" do
@@ -121,11 +121,11 @@ describe AdditionalDateFormatSelector do
     it "returns a list of all available patterns" do
       patterns = selector.patterns
       patterns.should be_a(Array)
-      patterns.should include(:MMMd)
-      patterns.should include(:yQQQ)
-      patterns.should include(:yQQQQ)
-      patterns.should include(:EHms)
-      patterns.should include(:d)
+      patterns.should include("MMMd")
+      patterns.should include("yQQQ")
+      patterns.should include("yQQQQ")
+      patterns.should include("EHms")
+      patterns.should include("d")
     end
   end
 

data/spec/data_readers/date_time_data_reader_spec.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::DataReaders
+
+describe DateTimeDataReader do
+  let(:data_reader) { DateTimeDataReader.new(:es) }
+
+  describe "#initialize" do
+    it "chooses gregorian as the calendar type if none is specified" do
+      DateTimeDataReader.new(:es).calendar_type.should == :gregorian
+      DateTimeDataReader.new(:es, :calendar_type => :julian).calendar_type.should == :julian
+    end
+  end
+
+  describe "#pattern" do
+    it "as of CLDR 23, should choose the medium date time path if no other type is specified" do
+      mock.proxy(data_reader).path_for(:medium, anything)
+      data_reader.pattern
+    end
+  end
+end

data/spec/data_readers/number_data_reader_spec.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::DataReaders
+
+describe NumberDataReader do
+  let(:data_reader) { NumberDataReader.new(:en) }
+
+  describe "#get_key_for" do
+    it "builds a power-of-ten key based on the number of digits in the input" do
+      (3..15).each { |i| data_reader.send(:get_key_for, "1337#{"0" * (i - 3)}").should == 10 ** i }
+    end
+  end
+end

data/spec/data_readers/timespan_data_reader.rb

@@ -0,0 +1,22 @@
+    it "should read correct tokens from custom locale" do
+      tokenizer = TimespanTokenizer.new(:locale => :sv)
+      one_day_ago = tokenizer.tokens(:unit => :day, :direction => :ago, :number => 1, :type => :default)
+      one_day_ago[0].should == { :value => "för ", :type => :plaintext }
+      one_day_ago[1].should == { :value => "{0}", :type => :placeholder }
+      one_day_ago[2].should == { :value => " dag sedan", :type => :plaintext }
+
+      two_days_ago = tokenizer.tokens(:unit => :day, :direction => :ago, :number => 2, :type => :default)
+      two_days_ago[0].should == { :value => "för ", :type => :plaintext }
+      two_days_ago[1].should == { :value => "{0}", :type => :placeholder }
+      two_days_ago[2].should == { :value => " dagar sedan", :type => :plaintext }
+
+      one_day_until = tokenizer.tokens(:unit => :day, :direction => :until, :number => 1, :type => :default)
+      one_day_until[0].should == { :value => "om ", :type => :plaintext }
+      one_day_until[1].should == { :value => "{0}", :type => :placeholder }
+      one_day_until[2].should == { :value => " dag", :type => :plaintext }
+
+      two_days_until = tokenizer.tokens(:unit => :day, :direction => :until, :number => 2, :type => :default)
+      two_days_until[0].should == { :value => "om ", :type => :plaintext }
+      two_days_until[1].should == { :value => "{0}", :type => :placeholder }
+      two_days_until[2].should == { :value => " dagar", :type => :plaintext }
+    end

data/spec/formatters/calendars/datetime_formatter_spec.rb

@@ -9,7 +9,8 @@ include TwitterCldr::Formatters
 
 describe DateTimeFormatter do
   before(:each) do
-    @formatter = DateTimeFormatter.new(:locale => :de)
+    data_reader = DateTimeDataReader.new(:de)
+    @formatter = DateTimeFormatter.new(data_reader)
   end
 
   describe "#day" do
@@ -394,42 +395,37 @@ describe DateTimeFormatter do
 
   describe "#era" do
     before(:each) do
-      @formatter = DateTimeFormatter.new(:locale => :en)
+      data_reader = DateTimeDataReader.new(:en)
+      @formatter = DateTimeFormatter.new(data_reader)
     end
 
     it "test: pattern G" do
-      @formatter.send(:era, Date.new(2012, 1, 1), 'G', 1).should == "AD"
-      @formatter.send(:era, Date.new(-1, 1, 1), 'G', 1).should == "BC"
+      @formatter.send(:era, Date.new(2012, 1, 1), 'G', 1).should == "CE"
+      @formatter.send(:era, Date.new(-1, 1, 1), 'G', 1).should == "BCE"
     end
 
     it "test: pattern GG" do
-      @formatter.send(:era, Date.new(2012, 1, 1), 'GG', 2).should == "AD"
-      @formatter.send(:era, Date.new(-1, 1, 1), 'GG', 2).should == "BC"
+      @formatter.send(:era, Date.new(2012, 1, 1), 'GG', 2).should == "CE"
+      @formatter.send(:era, Date.new(-1, 1, 1), 'GG', 2).should == "BCE"
     end
 
     it "test: pattern GGG" do
-      @formatter.send(:era, Date.new(2012, 1, 1), 'GGG', 3).should == "AD"
-      @formatter.send(:era, Date.new(-1, 1, 1), 'GGG', 3).should == "BC"
+      @formatter.send(:era, Date.new(2012, 1, 1), 'GGG', 3).should == "CE"
+      @formatter.send(:era, Date.new(-1, 1, 1), 'GGG', 3).should == "BCE"
     end
 
     it "test: pattern GGGG" do
-      @formatter.send(:era, Date.new(2012, 1, 1), 'GGGG', 4).should == "Anno Domini"
-      @formatter.send(:era, Date.new(-1, 1, 1), 'GGGG', 4).should == "Before Christ"
+      @formatter.send(:era, Date.new(2012, 1, 1), 'GGGG', 4).should == "Common Era"
+      @formatter.send(:era, Date.new(-1, 1, 1), 'GGGG', 4).should == "Before Common Era"
     end
 
     it "should fall back if the calendar doesn't contain the appropriate era data" do
-      stub(@formatter.tokenizer).calendar do
-        {
-          :eras => {
-            :abbr => {
-              0 => "abbr0",
-              1 => "abbr1"
-            },
-            :name => {
-              0 => "name0"
-            }
-          }
-        }
+      stub(@formatter.data_reader.calendar).eras(:abbr) do
+        { 0 => "abbr0", 1 => "abbr1" }
+      end
+
+      stub(@formatter.data_reader.calendar).eras(:name) do
+        { 0 => "name0" }
       end
 
       date = Date.new(2012, 1, 1)

data/spec/formatters/list_formatter_spec.rb

@@ -10,109 +10,38 @@ include TwitterCldr::Formatters
 describe ListFormatter do
   describe '#initialize' do
     it 'fetches locale from options hash' do
-      ListFormatter.new(:locale => :pt).locale.should == :pt
+      ListFormatter.new(:pt).locale.should == :pt
     end
 
     it "uses default locale if it's not passed in options hash" do
-      ListFormatter.new.locale.should == TwitterCldr::DEFAULT_LOCALE
+      ListFormatter.new.locale.should == TwitterCldr.locale
     end
   end
 
-  context "with an initialized list formatter" do
-    before(:each) do
-      @formatter = ListFormatter.new
-    end
-
-    describe "#compose" do
-      it "should reorder rtl lists" do
-        list = ["larry", "curly"]
-        @formatter.locale = :ar
-        @formatter.send(:compose, "{0} \331\210 {1}", list).should == "curly \331\210 larry"
-      end
-
-      it "should format a variable number of elements correctly" do
-        list = ["larry", "curly", "moe"]
-        @formatter.send(:compose, "{0} - {1} - {2}", list).should == "larry - curly - moe"
-        @formatter.send(:compose, "{0} - {1}", list).should == "larry - curly"
-        @formatter.send(:compose, "{0}", list).should == "larry"
-        @formatter.send(:compose, "", list).should == ""
-      end
-
-      it "should return the first element if the list only contains a single element" do
-        @formatter.send(:compose, "{0} - {1}", ["larry"]).should == "larry"
-      end
-
-      it "should return an empty string if the list is empty" do
-        @formatter.send(:compose, "{0} - {1}", []).should == ""
-      end
-    end
-
-    context "with a standard resource" do
-      before(:each) do
-        stub(@formatter).resource do
-          {
-            2       => "{0} $ {1}",
-            :middle => "{0}; {1}",
-            :start  => "{0}< {1}",
-            :end    => "{0}> {1}"
-          }
-        end
-      end
-
-      describe "#compose_list" do
-        it "should compose a list with two elements using the :end format" do
-          @formatter.send(:compose_list, ["larry", "curly"]).should == "larry> curly"
-        end
-
-        it "should compose a list with three elements using the :start and :end formats" do
-          @formatter.send(:compose_list, ["larry", "curly", "moe"]).should == "larry< curly> moe"
-        end
-
-        it "should compose a list with four elements using all the formats (:start, :middle, and :end)" do
-          @formatter.send(:compose_list, ["larry", "curly", "moe", "jerry"]).should == "larry< curly; moe> jerry"
-        end
-
-        it "should compose a list of five elements just for the hell of it" do
-          @formatter.send(:compose_list, ["larry", "curly", "moe", "jerry", "helga"]).should == "larry< curly; moe; jerry> helga"
-        end
-      end
-
-      describe "#format" do
-        it "should format correctly using the integer index if it exists" do
-          @formatter.format(["larry", "curly"]).should == "larry $ curly"
-        end
-
-        it "should format correctly if no corresponding integer index exists" do
-          @formatter.format(["larry", "curly", "moe"]).should == "larry< curly> moe"
-        end
-      end
-    end
+  describe "#format" do
+    let(:list) { ["larry", "curly", "moe"] }
 
-    context "with a resource that doesn't contain a start or end" do
+    context "with an English list formatter" do
       before(:each) do
-        stub(@formatter).resource do
-          { :middle => "{0}; {1}" }
-        end
+        @formatter = ListFormatter.new(:en)
       end
 
-      describe "#compose_list" do
-        it "should correctly compose a list with four elements, falling back to :middle for the beginning and end" do
-          @formatter.send(:compose_list, ["larry", "curly", "moe", "jerry"]).should == "larry; curly; moe; jerry"
-        end
+      it "formats English lists correctly using various types" do
+        @formatter.format(list).should == "larry, curly, and moe"
+        @formatter.format(list, :unit).should == "larry, curly, moe"
+        @formatter.format(list, :"unit-narrow").should == "larry curly moe"
       end
     end
 
-    context "with an empty resource" do
+    context "with a Spanish list formatter" do
       before(:each) do
-        stub(@formatter).resource do
-          {}
-        end
+        @formatter = ListFormatter.new(:es)
       end
 
-      describe "#compose_list" do
-        it "should return a blank string since no formats are available" do
-          @formatter.send(:compose_list, ["larry", "curly", "moe"]).should == ""
-        end
+      it "formats Spanish lists correctly using various types" do
+        @formatter.format(list).should == "larry, curly y moe"
+        @formatter.format(list, :unit).should == "larry, curly y moe"
+        @formatter.format(list, :"unit-narrow").should == "larry curly moe"
       end
     end
   end

data/spec/formatters/numbers/abbreviated/abbreviated_number_formatter_spec.rb

@@ -8,74 +8,30 @@ require 'spec_helper'
 include TwitterCldr::Formatters
 
 describe AbbreviatedNumberFormatter do
-  before(:each) do
-    @formatter = AbbreviatedNumberFormatter.new(:locale => :en)
-  end
+  let(:formatter) { AbbreviatedNumberFormatter.new(:locale => :en) }
 
   describe "#transform_number" do
     it "chops off the number to the necessary number of sig figs" do
-      @formatter.send(:transform_number, 10 ** 3).should == 1
-      @formatter.send(:transform_number, 10 ** 4).should == 10
-      @formatter.send(:transform_number, 10 ** 5).should == 100
-      @formatter.send(:transform_number, 10 ** 6).should == 1
-      @formatter.send(:transform_number, 10 ** 7).should == 10
-      @formatter.send(:transform_number, 10 ** 8).should == 100
-      @formatter.send(:transform_number, 10 ** 9).should == 1
-      @formatter.send(:transform_number, 10 ** 10).should == 10
-      @formatter.send(:transform_number, 10 ** 11).should == 100
-      @formatter.send(:transform_number, 10 ** 12).should == 1
-      @formatter.send(:transform_number, 10 ** 13).should == 10
-      @formatter.send(:transform_number, 10 ** 14).should == 100
+      formatter.send(:transform_number, 10 ** 3).should == 1
+      formatter.send(:transform_number, 10 ** 4).should == 10
+      formatter.send(:transform_number, 10 ** 5).should == 100
+      formatter.send(:transform_number, 10 ** 6).should == 1
+      formatter.send(:transform_number, 10 ** 7).should == 10
+      formatter.send(:transform_number, 10 ** 8).should == 100
+      formatter.send(:transform_number, 10 ** 9).should == 1
+      formatter.send(:transform_number, 10 ** 10).should == 10
+      formatter.send(:transform_number, 10 ** 11).should == 100
+      formatter.send(:transform_number, 10 ** 12).should == 1
+      formatter.send(:transform_number, 10 ** 13).should == 10
+      formatter.send(:transform_number, 10 ** 14).should == 100
     end
 
     it "returns the original number if greater than 10^15" do
-      @formatter.send(:transform_number, 10 ** 15).should == 10 ** 15
+      formatter.send(:transform_number, 10 ** 15).should == 10 ** 15
     end
 
     it "returns the original number if less than 10^3" do
-      @formatter.send(:transform_number, 999).should == 999
-    end
-  end
-
-  describe "#get_key" do
-    it "builds a power-of-ten key based on the number of digits in the input" do
-      (3..15).each { |i| @formatter.send(:get_key, "1337#{"0" * (i - 3)}").should == 10 ** i }
-    end
-  end
-
-  describe "#get_tokens" do
-    before(:each) do
-      stub(@formatter).get_type { :awesome_type }
-    end
-
-    it "gets tokens for a valid number (between 10^3 and 10^15)" do
-      mock(@formatter.tokenizer).tokens({
-        :sign => :positive,
-        :type => :awesome_type,
-        :format => 10 ** 4
-      }) { "I'm just right!" }
-
-      @formatter.get_tokens(12345).should == "I'm just right!"
-    end
-
-    it "returns tokens for decimals if the number is too large" do
-      mock(@formatter.tokenizer).tokens({
-        :sign => :positive,
-        :type => :decimal,
-        :format => nil
-      }) { "I'm too big!" }
-
-      @formatter.get_tokens(1234567891011122).should == "I'm too big!"
-    end
-
-    it "returns tokens for decimals if the number is too small" do
-      mock(@formatter.tokenizer).tokens({
-        :sign => :positive,
-        :type => :decimal,
-        :format => nil
-      }) { "I'm too small!" }
-
-      @formatter.get_tokens(123).should == "I'm too small!"
+      formatter.send(:transform_number, 999).should == 999
     end
   end
 end

data/spec/formatters/numbers/abbreviated/long_decimal_formatter_spec.rb

@@ -8,34 +8,49 @@ require 'spec_helper'
 include TwitterCldr::Formatters
 
 describe LongDecimalFormatter do
-  before(:each) do
-    @formatter = LongDecimalFormatter.new(:locale => :en)
+  let(:data_reader) do
+    TwitterCldr::DataReaders::NumberDataReader.new(:en, :type => :long_decimal)
   end
 
+  let(:formatter) { data_reader.formatter }
+  let(:tokenizer) { data_reader.tokenizer }
+
   it "formats valid numbers correctly (from 10^3 - 10^15)" do
-    @formatter.format(10 ** 3).should match_normalized("1 thousand")
-    @formatter.format(10 ** 4).should match_normalized("10 thousand")
-    @formatter.format(10 ** 5).should match_normalized("100 thousand")
-    @formatter.format(10 ** 6).should match_normalized("1 million")
-    @formatter.format(10 ** 7).should match_normalized("10 million")
-    @formatter.format(10 ** 8).should match_normalized("100 million")
-    @formatter.format(10 ** 9).should match_normalized("1 billion")
-    @formatter.format(10 ** 10).should match_normalized("10 billion")
-    @formatter.format(10 ** 11).should match_normalized("100 billion")
-    @formatter.format(10 ** 12).should match_normalized("1 trillion")
-    @formatter.format(10 ** 13).should match_normalized("10 trillion")
-    @formatter.format(10 ** 14).should match_normalized("100 trillion")
+    expected = {
+      10 ** 3 => "1 thousand",
+      10 ** 4 => "10 thousand",
+      10 ** 5 => "100 thousand",
+      10 ** 6 => "1 million",
+      10 ** 7 => "10 million",
+      10 ** 8 => "100 million",
+      10 ** 9 => "1 billion",
+      10 ** 10 => "10 billion",
+      10 ** 11 => "100 billion",
+      10 ** 12 => "1 trillion",
+      10 ** 13 => "10 trillion",
+      10 ** 14 => "100 trillion"
+    }
+
+    expected.each do |num, text|
+      pattern = data_reader.pattern(num)
+      formatter.format(tokenizer.tokenize(pattern), num).should == text
+    end
+  end
+
+  def format_number(number, options = {})
+    pattern = data_reader.pattern(number)
+    formatter.format(tokenizer.tokenize(pattern), number, options)
   end
 
   it "formats the number as if it were a straight decimal if it exceeds 10^15" do
-    @formatter.format(10**15).should == "1,000,000,000,000,000"
+    format_number(10**15).should == "1,000,000,000,000,000"
   end
 
   it "formats the number as if it were a straight decimal if it's less than 1000" do
-    @formatter.format(500).should == "500"
+    format_number(500).should == "500"
   end
 
   it "respects the :precision option" do
-    @formatter.format(12345, :precision => 3).should match_normalized("12.345 thousand")
+    format_number(12345, :precision => 3).should match_normalized("12.345 thousand")
   end
 end

data/spec/formatters/numbers/abbreviated/short_decimal_formatter_spec.rb

@@ -8,34 +8,50 @@ require 'spec_helper'
 include TwitterCldr::Formatters
 
 describe ShortDecimalFormatter do
-  before(:each) do
-    @formatter = ShortDecimalFormatter.new(:locale => :en)
+  let(:data_reader) do
+    TwitterCldr::DataReaders::NumberDataReader.new(:en, :type => :short_decimal)
   end
 
+  let(:formatter) { data_reader.formatter }
+  let(:tokenizer) { data_reader.tokenizer }
+
   it "formats valid numbers correctly (from 10^3 - 10^15)" do
-    @formatter.format(10 ** 3).should match_normalized("1K")
-    @formatter.format(10 ** 4).should match_normalized("10K")
-    @formatter.format(10 ** 5).should match_normalized("100K")
-    @formatter.format(10 ** 6).should match_normalized("1M")
-    @formatter.format(10 ** 7).should match_normalized("10M")
-    @formatter.format(10 ** 8).should match_normalized("100M")
-    @formatter.format(10 ** 9).should match_normalized("1B")
-    @formatter.format(10 ** 10).should match_normalized("10B")
-    @formatter.format(10 ** 11).should match_normalized("100B")
-    @formatter.format(10 ** 12).should match_normalized("1T")
-    @formatter.format(10 ** 13).should match_normalized("10T")
-    @formatter.format(10 ** 14).should match_normalized("100T")
+    expected = {
+      10 ** 3 => "1K",
+      10 ** 4 => "10K",
+      10 ** 5 => "100K",
+      10 ** 6 => "1M",
+      10 ** 7 => "10M",
+      10 ** 8 => "100M",
+      10 ** 9 => "1B",
+      10 ** 10 => "10B",
+      10 ** 11 => "100B",
+      10 ** 12 => "1T",
+      10 ** 13 => "10T",
+      10 ** 14 => "100T"
+    }
+
+    expected.each do |num, text|
+      pattern = data_reader.pattern(num)
+      formatter.format(tokenizer.tokenize(pattern), num).should == text
+    end
   end
 
   it "formats the number as if it were a straight decimal if it exceeds 10^15" do
-    @formatter.format(10**15).should == "1,000,000,000,000,000"
+    number = 10**15
+    pattern = data_reader.pattern(number)
+    formatter.format(tokenizer.tokenize(pattern), number).should == "1,000,000,000,000,000"
   end
 
   it "formats the number as if it were a straight decimal if it's less than 1000" do
-    @formatter.format(500).should == "500"
+    number = 500
+    pattern = data_reader.pattern(number)
+    formatter.format(tokenizer.tokenize(pattern), number).should == "500"
   end
 
   it "respects the :precision option" do
-    @formatter.format(12345, :precision => 3).should match_normalized("12.345K")
+    number = 12345
+    pattern = data_reader.pattern(number)
+    formatter.format(tokenizer.tokenize(pattern), number, :precision => 3).should match_normalized("12.345K")
   end
 end