twitter_cldr 3.0.1 → 3.0.2

data/spec/utils/interpolation_spec.rb

@@ -16,106 +16,106 @@ describe TwitterCldr::Utils do
 
     context 'when argument is a Hash' do
       it 'does nothing if no placeholder give' do
-        TwitterCldr::Utils.interpolate('foo', :foo => 'bar').should == 'foo'
+        expect(TwitterCldr::Utils.interpolate('foo', :foo => 'bar')).to eq('foo')
       end
 
       it 'interpolates named placeholders' do
-        TwitterCldr::Utils.interpolate('%{digit} %{sign} %{digit}', :digit => 2, :sign => '+').should == '2 + 2'
+        expect(TwitterCldr::Utils.interpolate('%{digit} %{sign} %{digit}', :digit => 2, :sign => '+')).to eq('2 + 2')
       end
 
       it 'interpolates named placeholders with formatting' do
-        TwitterCldr::Utils.interpolate(
+        expect(TwitterCldr::Utils.interpolate(
             '%<as_integer>d %<as_float>.2f', :as_integer => 3.14, :as_float => 15
-        ).should == '3 15.00'
+        )).to eq('3 15.00')
       end
 
       it 'interpolates mixed placeholders' do
-        TwitterCldr::Utils.interpolate(
+        expect(TwitterCldr::Utils.interpolate(
             '%{regular} is approx. %<pi>.4f', :regular => 'pi', :pi => 3.141592
-        ).should == 'pi is approx. 3.1416'
+        )).to eq('pi is approx. 3.1416')
       end
 
       it 'does not recurse' do
-        TwitterCldr::Utils.interpolate(
+        expect(TwitterCldr::Utils.interpolate(
             '%{top_level}', :top_level => '%<second_level>', :second_level => 'unexpected'
-        ).should == '%<second_level>'
+        )).to eq('%<second_level>')
       end
 
       it 'treats % before placeholder as escape character' do
-        TwitterCldr::Utils.interpolate(
+        expect(TwitterCldr::Utils.interpolate(
             '%%{foo} = %{foo}, %%<bar>d = %<bar>d', :foo => 1, :bar => 2.3
-        ).should == '%{foo} = 1, %<bar>d = 2'
+        )).to eq('%{foo} = 1, %<bar>d = 2')
       end
 
       it 'interpolates formatted placeholders as Ruby 1.9' do
-        TwitterCldr::Utils.interpolate('%<msg>s',    :msg => 'foo').should == 'foo'
-        TwitterCldr::Utils.interpolate('%<num>d',    :num => 1    ).should == '1'
-        TwitterCldr::Utils.interpolate('%<num>f',    :num => 1.0  ).should == '1.000000'
-        TwitterCldr::Utils.interpolate('%<num>3.0f', :num => 1.0  ).should == '  1'
-        TwitterCldr::Utils.interpolate('%<num>2.2f', :num => 100.0).should == '100.00'
-        TwitterCldr::Utils.interpolate('%<num>#b',   :num => 1    ).should == '0b1'
-        TwitterCldr::Utils.interpolate('%<num>#x',   :num => 100.0).should == '0x64'
+        expect(TwitterCldr::Utils.interpolate('%<msg>s',    :msg => 'foo')).to eq('foo')
+        expect(TwitterCldr::Utils.interpolate('%<num>d',    :num => 1    )).to eq('1')
+        expect(TwitterCldr::Utils.interpolate('%<num>f',    :num => 1.0  )).to eq('1.000000')
+        expect(TwitterCldr::Utils.interpolate('%<num>3.0f', :num => 1.0  )).to eq('  1')
+        expect(TwitterCldr::Utils.interpolate('%<num>2.2f', :num => 100.0)).to eq('100.00')
+        expect(TwitterCldr::Utils.interpolate('%<num>#b',   :num => 1    )).to eq('0b1')
+        expect(TwitterCldr::Utils.interpolate('%<num>#x',   :num => 100.0)).to eq('0x64')
       end
 
       it 'ignores extra values' do
-        TwitterCldr::Utils.interpolate('%{msg}', :msg => 'hello', :extra => 'extra').should == 'hello'
+        expect(TwitterCldr::Utils.interpolate('%{msg}', :msg => 'hello', :extra => 'extra')).to eq('hello')
       end
 
       it 'raises ArgumentError if formatted placeholder is malformed' do
-        lambda { TwitterCldr::Utils.interpolate('%<num>,d', :num => 100) }.should raise_error(ArgumentError)
-        lambda { TwitterCldr::Utils.interpolate('%<num>/d', :num => 100) }.should raise_error(ArgumentError)
+        expect { TwitterCldr::Utils.interpolate('%<num>,d', :num => 100) }.to raise_error(ArgumentError)
+        expect { TwitterCldr::Utils.interpolate('%<num>/d', :num => 100) }.to raise_error(ArgumentError)
       end
 
       it 'raises KeyError when the value is missing' do
-        lambda { TwitterCldr::Utils.interpolate('%{msg}', {}) }.should raise_error(KeyError)
+        expect { TwitterCldr::Utils.interpolate('%{msg}', {}) }.to raise_error(KeyError)
       end
     end
 
     context 'when argument is an Array' do
       it 'does nothing if no placeholder give' do
-        TwitterCldr::Utils.interpolate('foo', [111]).should == 'foo'
+        expect(TwitterCldr::Utils.interpolate('foo', [111])).to eq('foo')
       end
 
       it 'interpolates all placeholders' do
-        TwitterCldr::Utils.interpolate('%d %s', [12, 'monkeys']).should == '12 monkeys'
+        expect(TwitterCldr::Utils.interpolate('%d %s', [12, 'monkeys'])).to eq('12 monkeys')
       end
 
       it 'interpolates all placeholders with formatting' do
-        TwitterCldr::Utils.interpolate('%d %.3f %#b', [3.1415, 92, 6]).should == '3 92.000 0b110'
+        expect(TwitterCldr::Utils.interpolate('%d %.3f %#b', [3.1415, 92, 6])).to eq('3 92.000 0b110')
       end
 
       it 'formats positional arguments' do
-        TwitterCldr::Utils.interpolate('%1$*2$s %2$d %1$s', ['hello', 8]).should == '   hello 8 hello'
+        expect(TwitterCldr::Utils.interpolate('%1$*2$s %2$d %1$s', ['hello', 8])).to eq('   hello 8 hello')
       end
 
       it 'treats % as escape character' do
-        TwitterCldr::Utils.interpolate('%s: %+.2f±%.2f%%', ['total', 3.14159, 2.6535]).should == 'total: +3.14±2.65%'
+        expect(TwitterCldr::Utils.interpolate('%s: %+.2f±%.2f%%', ['total', 3.14159, 2.6535])).to eq('total: +3.14±2.65%')
       end
 
       it 'ignores extra values' do
-        TwitterCldr::Utils.interpolate('%d', [2, 1]).should == '2'
+        expect(TwitterCldr::Utils.interpolate('%d', [2, 1])).to eq('2')
       end
 
       it 'raises ArgumentError when given not enough values' do
-        lambda { TwitterCldr::Utils.interpolate('%d %d', [1]) }.should raise_error(ArgumentError)
+        expect { TwitterCldr::Utils.interpolate('%d %d', [1]) }.to raise_error(ArgumentError)
       end
 
       it 'raises ArgumentError if the string contains named placeholders' do
-        lambda { TwitterCldr::Utils.interpolate('%{name} %d', [1, 2]) }.should raise_error(ArgumentError)
+        expect { TwitterCldr::Utils.interpolate('%{name} %d', [1, 2]) }.to raise_error(ArgumentError)
       end
     end
 
     context 'when argument is a single value' do
       it 'formats a string' do
-        TwitterCldr::Utils.interpolate('a string: %s', 'string').should == 'a string: string'
+        expect(TwitterCldr::Utils.interpolate('a string: %s', 'string')).to eq('a string: string')
       end
 
       it 'formats a number' do
-        TwitterCldr::Utils.interpolate('a number: %4.1f', 3.1415).should == 'a number:  3.1'
+        expect(TwitterCldr::Utils.interpolate('a number: %4.1f', 3.1415)).to eq('a number:  3.1')
       end
 
       it 'raises ArgumentError if the string contains named placeholders' do
-        lambda { TwitterCldr::Utils.interpolate('%{name}', 'must be hash') }.should raise_error(ArgumentError)
+        expect { TwitterCldr::Utils.interpolate('%{name}', 'must be hash') }.to raise_error(ArgumentError)
       end
     end
 

data/spec/utils/range_set_spec.rb

@@ -10,48 +10,48 @@ include TwitterCldr::Utils
 describe RangeSet do
   describe "rangify" do
     it "should identify runs in an array of integers and return an array of ranges" do
-      RangeSet.rangify([1, 2, 3, 6, 7, 8, 11, 14, 17, 18, 19]).
-        should == [1..3, 6..8, 11..11, 14..14, 17..19]
+      expect(RangeSet.rangify([1, 2, 3, 6, 7, 8, 11, 14, 17, 18, 19])).
+        to eq([1..3, 6..8, 11..11, 14..14, 17..19])
     end
 
     it "should not rangify zero-length values when told to compress" do
-      RangeSet.rangify([1, 2, 3, 5, 8, 11, 12], true).
-        should == [1..3, 5, 8, 11..12]
+      expect(RangeSet.rangify([1, 2, 3, 5, 8, 11, 12], true)).
+        to eq([1..3, 5, 8, 11..12])
     end
   end
 
   describe "#to_a" do
     it "should return a copy of the ranges in the set" do
       set = RangeSet.new([1..10])
-      set.to_a.object_id.should_not == set.ranges.object_id
+      expect(set.to_a.object_id).not_to eq(set.ranges.object_id)
     end
 
     it "should return compressed ranges when asked" do
-      RangeSet.new([1..10, 12..12]).to_a(true).should == [1..10, 12]
+      expect(RangeSet.new([1..10, 12..12]).to_a(true)).to eq([1..10, 12])
     end
   end
 
   describe "#to_full_a" do
     it "expands all ranges" do
-      RangeSet.new([1..5]).to_full_a.should == [1, 2, 3, 4, 5]
+      expect(RangeSet.new([1..5]).to_full_a).to eq([1, 2, 3, 4, 5])
     end
   end
 
   describe "#new" do
     it "should flatten leading overlapping ranges" do
-      RangeSet.new([3..10, 1..8]).to_a.should == [1..10]
+      expect(RangeSet.new([3..10, 1..8]).to_a).to eq([1..10])
     end
 
     it "should flatten trailing overlapping ranges" do
-      RangeSet.new([1..10, 8..12]).to_a.should == [1..12]
+      expect(RangeSet.new([1..10, 8..12]).to_a).to eq([1..12])
     end
 
     it "should flatten completely overlapping ranges" do
-      RangeSet.new([2..3, 1..10]).to_a.should == [1..10]
+      expect(RangeSet.new([2..3, 1..10]).to_a).to eq([1..10])
     end
 
     it "should join ranges that are within 1 of each other" do
-      RangeSet.new([1..10, 11..15]).to_a.should == [1..15]
+      expect(RangeSet.new([1..10, 11..15]).to_a).to eq([1..15])
     end
   end
 
@@ -61,94 +61,94 @@ describe RangeSet do
         RangeSet.new([9..11, 1..2, 2..3, 14..18])
       )
 
-      set.to_a.should == [1..11, 14..18]
+      expect(set.to_a).to eq([1..11, 14..18])
     end
 
     it "should aggregate the ranges correctly even if they're given in reverse order" do
       set = RangeSet.new([3..10]).union(RangeSet.new([1..4]))
-      set.to_a.should == [1..10]
+      expect(set.to_a).to eq([1..10])
 
       set = RangeSet.new([1..4]).union(RangeSet.new([3..10]))
-      set.to_a.should == [1..10]
+      expect(set.to_a).to eq([1..10])
     end
   end
 
   describe "#intersection" do
     it "computes the intersection for leading overlapping ranges" do
       set = RangeSet.new([3..10]).intersection(RangeSet.new([1..7]))
-      set.to_a.should == [3..7]
+      expect(set.to_a).to eq([3..7])
     end
 
     it "computes the intersection for trailing overlapping ranges" do
       set = RangeSet.new([1..10]).intersection(RangeSet.new([5..15]))
-      set.to_a.should == [5..10]
+      expect(set.to_a).to eq([5..10])
     end
 
     it "computes the intersection for two completely overlapping ranges" do
       set = RangeSet.new([1..10]).intersection(RangeSet.new([3..6]))
-      set.to_a.should == [3..6]
+      expect(set.to_a).to eq([3..6])
     end
 
     it "returns an empty intersection if no elements exist in both ranges" do
       set = RangeSet.new([1..10]).intersection(RangeSet.new([15..20]))
-      set.to_a.should == []
+      expect(set.to_a).to eq([])
     end
 
     it "returns partial intersections when the range set contains multiple matching ranges" do
       set = RangeSet.new([1..5, 7..10]).intersection(RangeSet.new([3..8]))
-      set.to_a.should == [3..5, 7..8]
+      expect(set.to_a).to eq([3..5, 7..8])
     end
 
     it "doesn't matter what order the ranges are compared in" do
       set = RangeSet.new([2..3]).intersection(RangeSet.new([1..4]))
-      set.to_a.should == [2..3]
+      expect(set.to_a).to eq([2..3])
 
       set = RangeSet.new([1..4]).intersection(RangeSet.new([2..3]))
-      set.to_a.should == [2..3]
+      expect(set.to_a).to eq([2..3])
     end
   end
 
   describe "#subtract" do
     it "subtracts the intersection for leading overlapping ranges" do
       set = RangeSet.new([3..10]).subtract(RangeSet.new([1..5]))
-      set.to_a.should == [6..10]
+      expect(set.to_a).to eq([6..10])
     end
 
     it "subtracts the intersection for trailing overlapping ranges" do
       set = RangeSet.new([1..7]).subtract(RangeSet.new([3..9]))
-      set.to_a.should == [1..2]
+      expect(set.to_a).to eq([1..2])
     end
 
     it "subtracts the intersection for completely overlapping ranges (generates two ranges)" do
       set = RangeSet.new([1..10]).subtract(RangeSet.new([4..6]))
-      set.to_a.should == [1..3, 7..10]
+      expect(set.to_a).to eq([1..3, 7..10])
     end
 
     it "subtracts the intersection when the range set contians multiple matching ranges" do
       set = RangeSet.new([1..5, 7..10]).subtract(RangeSet.new([3..8]))
-      set.to_a.should == [1..2, 9..10]
+      expect(set.to_a).to eq([1..2, 9..10])
     end
 
     it "does not change object when subtracting an empty set" do
       set = RangeSet.new([1..5]).subtract(RangeSet.new([]))
-      set.to_a.should == [1..5]
+      expect(set.to_a).to eq([1..5])
     end
   end
 
   describe "#difference" do
     it "returns the symmetric difference (union - intersection) between completely overlapping ranges" do
       set = RangeSet.new([1..10]).difference(RangeSet.new([3..8]))
-      set.to_a.should == [1..2, 9..10]
+      expect(set.to_a).to eq([1..2, 9..10])
     end
 
     it "returns the symmetric difference between leading overlapping ranges" do
       set = RangeSet.new([3..10]).difference(RangeSet.new([1..5]))
-      set.to_a.should == [1..2, 6..10]
+      expect(set.to_a).to eq([1..2, 6..10])
     end
 
     it "returns the symmetric difference between trailing overlapping ranges" do
       set = RangeSet.new([1..5]).difference(RangeSet.new([3..8]))
-      set.to_a.should == [1..2, 6..8]
+      expect(set.to_a).to eq([1..2, 6..8])
     end
   end
 
@@ -156,16 +156,16 @@ describe RangeSet do
     let (:set) { RangeSet.new([1..5, 9..16]) }
 
     it "returns true if the set completely includes the range, false otherwise" do
-      set.should include(10..15)
-      set.should_not include(3..8)
-      set.should_not include(8..14)
+      expect(set).to include(10..15)
+      expect(set).not_to include(3..8)
+      expect(set).not_to include(8..14)
     end
 
     it "returns true if the set contains the value, false otherwise" do
-      set.should include(3)
-      set.should include(10)
-      set.should_not include(6)
-      set.should_not include(8)
+      expect(set).to include(3)
+      expect(set).to include(10)
+      expect(set).not_to include(6)
+      expect(set).not_to include(8)
     end
   end
 end

data/spec/utils/regexp_ast_spec.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Utils
+
+describe RegexpAst do
+  let(:ast) do
+    RegexpAst::Root.new(
+      [RegexpAst::Literal.new([], nil, 'foobar')], nil
+    )
+  end
+
+  let(:ast_dump) do
+    "BAhvOihUd2l0dGVyQ2xkcjo6VXRpbHM6OlJlZ2V4cEFzdDo6Um9vdAc6EUBl\n" +
+    "eHByZXNzaW9uc1sGbzorVHdpdHRlckNsZHI6OlV0aWxzOjpSZWdleHBBc3Q6\n" +
+    "OkxpdGVyYWwIOgpAdGV4dEkiC2Zvb2JhcgY6BkVUOwZbADoQQHF1YW50aWZp\n" +
+    "ZXIwOwow\n"
+  end
+
+  def check_ast(obj)
+    obj.should be_a(RegexpAst::Root)
+    expr = obj.expressions.first
+    expr.should be_a(RegexpAst::Literal)
+    expr.text.should == 'foobar'
+  end
+
+  describe "#dump" do
+    it "should correctly serialize the ast" do
+      obj = Marshal.load(Base64.decode64(RegexpAst.dump(ast)))
+      check_ast(obj)
+    end
+  end
+
+  describe "#load" do
+    it "should load the dumped ast and construct a valid object" do
+      obj = RegexpAst.load(ast_dump)
+      check_ast(obj)
+    end
+  end
+end

data/spec/utils/regexp_sampler_spec.rb

@@ -0,0 +1,182 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Utils
+
+describe RegexpSampler do
+  let(:root) { RegexpAst::Root }
+  let(:digit) { RegexpAst::Digit }
+  let(:word) { RegexpAst::Word }
+  let(:literal) { RegexpAst::Literal }
+  let(:character_set) { RegexpAst::CharacterSet }
+  let(:capture) { RegexpAst::Capture }
+  let(:passive) { RegexpAst::Passive }
+  let(:sequence) { RegexpAst::Sequence }
+  let(:alternation) { RegexpAst::Alternation }
+  let(:quantifier) { RegexpAst::Quantifier }
+  let(:sampler) { RegexpSampler }
+
+  let(:singular_quantifier) { quantifier.new(2, 2) }
+  let(:ranged_quantifier) { quantifier.new(2, 4) }
+
+  def make(ast)
+    sampler.new(root.new([ast], nil))
+  end
+
+  around(:each) do |example|
+    10.times { example.run }
+  end
+
+  context "digits" do
+    it "should return a single digit when no quantifier" do
+      spl = make(digit.new([], nil))
+      spl.generate.should match(/\d/)
+    end
+
+    it "should return multiple digits when given a singular quantifier" do
+      spl = make(digit.new([], singular_quantifier))
+      spl.generate.should match(/\d{2}/)
+    end
+
+    it "should return the correct number of digits when given a ranged quantifier" do
+      spl = make(digit.new([], ranged_quantifier))
+      spl.generate.should match(/\d{2,4}/)
+    end
+  end
+
+  context "words" do
+    it "should return a single word character when no quantifier" do
+      spl = make(word.new([], nil))
+      spl.generate.should match(/\w/)
+    end
+
+    it "should return multiple letter characters when given a singular quantifier" do
+      spl = make(word.new([], singular_quantifier))
+      spl.generate.should match(/\w{2}/)
+    end
+
+    it "should return the correct number of word characters when given a ranged quantifier" do
+      spl = make(word.new([], ranged_quantifier))
+      spl.generate.should match(/\w{2,4}/)
+    end
+  end
+
+  context "literals" do
+    it "should return the literal when no quantifier" do
+      spl = make(literal.new([], nil, 'foobar'))
+      spl.generate.should == "foobar"
+    end
+
+    it "should return multiple copies of the literal when given a singular quantifier" do
+      spl = make(literal.new([], singular_quantifier, 'foobar'))
+      spl.generate.should == "foobarfoobar"
+    end
+
+    it "should return the correct number of literal copies when given a ranged quantifier" do
+      spl = make(literal.new([], ranged_quantifier, 'foobar'))
+      spl.generate.should match(/(foobar){2,4}/)
+    end
+  end
+
+  context "character sets" do
+    it "should handle single characters correctly" do
+      spl = make(character_set.new([], nil, ['a', 'b', 'c'], false))
+      spl.generate.should match(/[abc]/)
+    end
+
+    it "should repeat characters when given a singular quantifier" do
+      spl = make(character_set.new([], singular_quantifier, ['a', 'b', 'c'], false))
+      spl.generate.should match(/[abc]{2}/)
+    end
+
+    it "should repeat characters when given a ranged quantifier" do
+      spl = make(character_set.new([], ranged_quantifier, ['a', 'b', 'c'], false))
+      spl.generate.should match(/[abc]{2,4}/)
+    end
+
+    it "should handle character ranges correctly" do
+      spl = make(character_set.new([], nil, ['a-z'], false))
+      spl.generate.should match(/[a-z]/)
+    end
+
+    it "should handle character ranges correctly when given a singular quantifier" do
+      spl = make(character_set.new([], singular_quantifier, ['a-z'], false))
+      spl.generate.should match(/[a-z]{2}/)
+    end
+
+    it "should handle character ranges correctly when given a ranged quantifier" do
+      spl = make(character_set.new([], ranged_quantifier, ['a-z'], false))
+      spl.generate.should match(/[a-z]{2,4}/)
+    end
+  end
+
+  context "captures" do
+    it "should ignore captures" do
+      spl = make(capture.new([digit.new([], nil)], nil))
+      spl.generate.should match(/\d/)
+    end
+  end
+
+  context "passives (i.e. non-capturing groups)" do
+    it "should ignore non-captures" do
+      spl = make(passive.new([digit.new([], nil)], nil))
+      spl.generate.should match(/\d/)
+    end
+  end
+
+  context "alternations" do
+    it "should alternate between the options" do
+      spl = make(alternation.new([
+        literal.new([], nil, 'a'), digit.new([], nil)
+      ], nil))
+
+      spl.generate.should match(/a|\d/)
+    end
+
+    it "should handle alternation when given a singlular quantifier" do
+      spl = make(alternation.new([
+        literal.new([], nil, 'a'), digit.new([], nil)
+      ], singular_quantifier))
+
+      spl.generate.should match(/(?:a|\d){2}/)
+    end
+
+    it "should handle alternation when given a ranged quantifier" do
+      spl = make(alternation.new([
+        literal.new([], nil, 'a'), digit.new([], nil)
+      ], ranged_quantifier))
+
+      spl.generate.should match(/(?:a|\d){2,4}/)
+    end
+  end
+
+  context "sequences" do
+    it "should process every element in the sequence" do
+      spl = make(sequence.new([
+        digit.new([], nil), word.new([], nil), literal.new([], nil, 'a')
+      ], nil))
+
+      spl.generate.should match(/\d\wa/)
+    end
+
+    it "should process every element the specified number of times with a singular quantifier" do
+      spl = make(sequence.new([
+        digit.new([], nil), word.new([], nil), literal.new([], nil, 'a')
+      ], singular_quantifier))
+
+      spl.generate.should match(/(?:\d\wa){2}/)
+    end
+
+    it "should process every element the specified number of times with a ranged quantifier" do
+      spl = make(sequence.new([
+        digit.new([], nil), word.new([], nil), literal.new([], nil, 'a')
+      ], ranged_quantifier))
+
+      spl.generate.should match(/(?:\d\wa){2,4}/)
+    end
+  end
+end