twitter_cldr 3.1.1 → 3.1.2

data/spec/bidi/bidi_spec.rb

@@ -28,7 +28,6 @@ describe Bidi do
     File.open(BIDI_TEST_PATH, 'r').each_line do |s|
       cur_line = s.strip
       first_char = cur_line[0]
-      first_char = first_char.chr if first_char.is_a?(Fixnum)  # conversion for ruby 1.8
 
       case first_char
         when "#"

data/spec/core_ext_spec.rb

@@ -10,8 +10,7 @@ describe 'Core classes localization' do
   [Array, Bignum, DateTime, Fixnum, Float, String, Symbol, Time].each do |klass|
     describe klass do
       it 'has public instance method #localize' do
-        # convert methods names to symbols (they're strings in 1.8)
-        expect(klass.public_instance_methods.map(&:to_sym)).to include(:localize)
+        expect(klass.public_instance_methods).to include(:localize)
       end
     end
   end

data/spec/parsers/segmentation_parser_spec.rb

@@ -30,20 +30,24 @@ describe "Segmentation" do
     describe "#parse" do
       it "should parse a rule with a break" do
         rule = parse(tokenize("[a-z] ÷ [0-9]"))
-        expect(rule.left.to_regexp_str).to eq("\\A(?:[\\141-\\172])")
-        expect(rule.right.to_regexp_str).to eq("\\A(?:[\\60-\\71])")
+        expect(rule.left.to_regexp_str).to eq("\\A(?:[\\u{0061}-\\u{007a}])")
+        expect(rule.right.to_regexp_str).to eq("\\A(?:[\\u{0030}-\\u{0039}])")
         expect(rule.boundary_symbol).to eq(:break)
       end
 
       it "should parse a rule with a non-break" do
         rule = parse(tokenize("[a-z] × [0-9]"))
-        expect(rule.regex.to_regexp_str).to eq("\\A(?:[\\141-\\172])(?:[\\60-\\71])")
+        expect(rule.regex.to_regexp_str).to eq(
+          "\\A(?:[\\u{0061}-\\u{007a}])(?:[\\u{0030}-\\u{0039}])"
+        )
         expect(rule.boundary_symbol).to eq(:no_break)
       end
 
       it "should parse a rule containing a variable" do
         rule = parse(tokenize("$FOO × bar"), :symbol_table => symbol_table)
-        expect(rule.regex.to_regexp_str).to eq("\\A(?:[\\141-\\143])(?:\\142)(?:\\141)(?:\\162)")
+        expect(rule.regex.to_regexp_str).to eq(
+          "\\A(?:[\\u{0061}-\\u{0063}])(?:\\u{0062})(?:\\u{0061})(?:\\u{0072})"
+        )
         expect(rule.boundary_symbol).to eq(:no_break)
       end
     end

data/spec/parsers/symbol_table_spec.rb

@@ -15,11 +15,7 @@ describe SymbolTable do
       expect(table.fetch(:a)).to eq("b")
       fetch = lambda { table.fetch(:z) }
 
-      if RUBY_VERSION > "1.8.7"
-        expect(fetch).to raise_error(KeyError)
-      else
-        expect(fetch).to raise_error(IndexError)
-      end
+      expect(fetch).to raise_error(KeyError)
     end
   end
 

data/spec/parsers/unicode_regex/character_class_spec.rb

@@ -102,17 +102,19 @@ describe UnicodeRegexParser::CharacterClass do
   describe "#to_regexp_str" do
     it "wraps ranges in square brackets" do
       char_class = char_class_from(parse(tokenize("[a-z]")))
-      expect(char_class.to_regexp_str).to eq("(?:[\\141-\\172])")
+      expect(char_class.to_regexp_str).to eq("(?:[\\u{0061}-\\u{007a}])")
     end
 
     it "octal-encodes and wraps sequential characters to isolate bytes" do
       char_class = char_class_from(parse(tokenize("[{foo}]")))
-      expect(char_class.to_regexp_str).to eq("(?:(?:\\146)(?:\\157)(?:\\157))")
+      expect(char_class.to_regexp_str).to eq("(?:(?:\\u{0066})(?:\\u{006f})(?:\\u{006f}))")
     end
 
     it "combines multiple components with 'or' pipe characters" do
       char_class = char_class_from(parse(tokenize("[{foo}abc]")))
-      expect(char_class.to_regexp_str).to eq("(?:(?:\\146)(?:\\157)(?:\\157)|[\\141-\\143])")
+      expect(char_class.to_regexp_str).to eq(
+        "(?:(?:\\u{0066})(?:\\u{006f})(?:\\u{006f})|[\\u{0061}-\\u{0063}])"
+      )
     end
   end
 end

data/spec/parsers/unicode_regex/unicode_string_spec.rb

@@ -21,7 +21,7 @@ describe UnicodeRegexParser::UnicodeString do
 
     it "should covert the codepoints to a valid regex" do
       str = UnicodeRegexParser::UnicodeString.new(97)
-      expect(str.to_regexp_str).to eq"(?:\\141)"
+      expect(str.to_regexp_str).to eq("(?:\\u{0061})")
     end
   end
 end

data/spec/shared/unicode_regex_spec.rb

@@ -31,34 +31,34 @@ describe UnicodeRegex do
 
     describe "#to_regexp_str" do
       it "should return the string representation of this regex" do
-        expect(regex.to_regexp_str).to eq("(?:[\\141-\\143])")
+        expect(regex.to_regexp_str).to eq("(?:[\\u{0061}-\\u{0063}])")
       end
     end
 
     describe "#to_regexp" do
       it "should return a ruby Regexp" do
-        if RUBY_VERSION <= "1.8.7"
-          expect(regex.to_regexp).to be_a(Oniguruma::ORegexp)
-        else
-          expect(regex.to_regexp).to be_a(Regexp)
-        end
+        expect(regex.to_regexp).to be_a(Regexp)
       end
 
       it "should properly turn various basic regexes into strings" do
-        expect(compile("^abc$").to_regexp_str).to eq("^(?:\\141)(?:\\142)(?:\\143)$")
-        expect(compile("a(b)c").to_regexp_str).to eq("(?:\\141)((?:\\142))(?:\\143)")
-        expect(compile("a(?:b)c").to_regexp_str).to eq("(?:\\141)(?:(?:\\142))(?:\\143)")
-        expect(compile("a{1,3}").to_regexp_str).to eq("(?:\\141){1,3}")
-        expect(compile("[abc]").to_regexp_str).to eq("(?:[\\141-\\143])")
+        expect(compile("^abc$").to_regexp_str).to eq("^(?:\\u{0061})(?:\\u{0062})(?:\\u{0063})$")
+        expect(compile("a(b)c").to_regexp_str).to eq("(?:\\u{0061})((?:\\u{0062}))(?:\\u{0063})")
+        expect(compile("a(?:b)c").to_regexp_str).to eq("(?:\\u{0061})(?:(?:\\u{0062}))(?:\\u{0063})")
+        expect(compile("a{1,3}").to_regexp_str).to eq("(?:\\u{0061}){1,3}")
+        expect(compile("[abc]").to_regexp_str).to eq("(?:[\\u{0061}-\\u{0063}])")
       end
 
       it "should properly turn various complex regexes into strings" do
-        expect(compile("[a-z0-9]").to_regexp_str).to eq("(?:[\\60-\\71]|[\\141-\\172])")
-        expect(compile("[\\u0067-\\u0071]").to_regexp_str).to eq("(?:[\\147-\\161])")
+        expect(compile("[a-z0-9]").to_regexp_str).to eq(
+          "(?:[\\u{0030}-\\u{0039}]|[\\u{0061}-\\u{007a}])"
+        )
+        expect(compile("[\\u0067-\\u0071]").to_regexp_str).to eq("(?:[\\u{0067}-\\u{0071}])")
       end
 
       it "should properly substitute variables" do
-        expect(compile("$FOO$BAR", symbol_table).to_regexp_str).to eq("(?:[\\147-\\153])(?:[\\160-\\163])")
+        expect(compile("$FOO$BAR", symbol_table).to_regexp_str).to eq(
+          "(?:[\\u{0067}-\\u{006b}])(?:[\\u{0070}-\\u{0073}])"
+        )
       end
     end
   end

data/spec/spec_helper.rb

@@ -6,19 +6,10 @@
 require 'rspec'
 require 'rspec/autorun' # somehow makes rcov work with rspec
 require 'twitter_cldr'
+require 'pry-nav'
+require 'coveralls'
 
-if defined?(RUBY_ENGINE)
-  if RUBY_ENGINE == "rbx"
-    require 'rubinius/debugger'
-  elsif RUBY_ENGINE == "ruby"
-    require 'pry-nav'
-  end
-end
-
-if RUBY_VERSION <= "1.8.7"
-  $KCODE = "UTF-8"
-  require 'oniguruma'
-end
+Coveralls.wear!
 
 if ENV['SCOV']
   require 'simplecov'

data/spec/utils/yaml/yaml_spec.rb

@@ -32,26 +32,14 @@ require 'yaml'
 # Psych doesn't handle Unicode characters properly, have to use Syck instead.
 if YAML.const_defined?(:ENGINE)
   # Fix undefined method `syck_to_yaml' for class `Object' error on MRI 1.9.3.
-  # Target only MRI >= 1.9, because on other Rubies, e.g., JRuby, requiring 'syck' results in a LoadError.
-  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby' && RUBY_VERSION >= "1.9.0" && RUBY_VERSION < "2.0.0"
+  # Target only MRI ~1.9, because on other Rubies, e.g., JRuby, requiring 'syck' results in a LoadError.
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby' && RUBY_VERSION < "2.0.0"
     require 'syck'
   end
 
   YAML::ENGINE.yamler = 'syck'
 end
 
-# There's an incompatibility in how ruby handles struct dumps
-# between versions that's beyond our scope.
-# (One uses strings internally, the other symbols.)
-# This just enables tests to pass.
-class << Struct
-  alias yaml_new_without_indifferent_keys yaml_new
-  def yaml_new(klass, tag, val)
-    val.keys.each { |k, v| val[k.to_sym] = val.delete(k) }
-    yaml_new_without_indifferent_keys(klass, tag, val)
-  end
-end if RUBY_VERSION >= "1.9" && RUBY_VERSION <= "1.9.1"  # yaml_new is deprecated in 1.9.2 and later
-
 STRUCT_KLASS = Struct::new('Foo', :bar, :buz)
 class Moo
   attr_accessor :val1, :val2
@@ -140,11 +128,9 @@ describe TwitterCldr::Utils do
       end
     end
 
-    if RUBY_VERSION >= "1.9"
-      it "should preserve hash order" do
-        h = { 'a' => 1, 'c' => 3, 'b' => 2 }
-        expect(TwitterCldr::Utils::YAML.dump(h, :preserve_order => true)).to eq("--- \na: 1\nc: 3\nb: 2\n")
-      end
+    it "should preserve hash order" do
+      h = { 'a' => 1, 'c' => 3, 'b' => 2 }
+      expect(TwitterCldr::Utils::YAML.dump(h, :preserve_order => true)).to eq("--- \na: 1\nc: 3\nb: 2\n")
     end
 
     it "tests normalization of line breaks" do
@@ -430,15 +416,13 @@ describe TwitterCldr::Utils do
     end
 
     it "tests binary dumps" do
-      unless RUBY_VERSION < '1.9.0'
-        y = nil
+      y = nil
 
-        expect { y = TwitterCldr::Utils::YAML.dump('日本語'.force_encoding('ASCII-8BIT')) }.not_to raise_error
-        expect(y).to eq("--- !binary |\n  5pel5pys6Kqe\n\n")
+      expect { y = TwitterCldr::Utils::YAML.dump('日本語'.force_encoding('ASCII-8BIT')) }.not_to raise_error
+      expect(y).to eq("--- !binary |\n  5pel5pys6Kqe\n\n")
 
-        expect { y = TwitterCldr::Utils::YAML.dump('日本語'.encode('EUC-JP').force_encoding('UTF-8')) }.not_to raise_error
-        expect(y).to eq("--- !binary |\n  xvzL3Ljs\n\n")
-      end
+      expect { y = TwitterCldr::Utils::YAML.dump('日本語'.encode('EUC-JP').force_encoding('UTF-8')) }.not_to raise_error
+      expect(y).to eq("--- !binary |\n  xvzL3Ljs\n\n")
     end
 
   end

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: twitter_cldr
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.1.2
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-18 00:00:00.000000000 Z
+date: 2015-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: camertron-eprun
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: tzinfo
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: cldr-plurals-runtime-rb
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.0
 description: Ruby implementation of the ICU (International Components for Unicode)
@@ -210,7 +210,6 @@ files:
 - lib/twitter_cldr/tokenizers/unicode_regex/unicode_regex_tokenizer.rb
 - lib/twitter_cldr/utils.rb
 - lib/twitter_cldr/utils/code_points.rb
-- lib/twitter_cldr/utils/interpolation.rb
 - lib/twitter_cldr/utils/range_set.rb
 - lib/twitter_cldr/utils/regexp_ast.rb
 - lib/twitter_cldr/utils/regexp_sampler.rb
@@ -1550,7 +1549,6 @@ files:
 - spec/tokenizers/unicode_regex/unicode_regex_tokenizer_spec.rb
 - spec/twitter_cldr_spec.rb
 - spec/utils/code_points_spec.rb
-- spec/utils/interpolation_spec.rb
 - spec/utils/range_set_spec.rb
 - spec/utils/regexp_ast_spec.rb
 - spec/utils/regexp_sampler_spec.rb
@@ -1568,19 +1566,20 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of the ICU (International Components for Unicode) that
   uses the Common Locale Data Repository to format dates, plurals, and more.
 test_files: []
+has_rdoc: true

data/lib/twitter_cldr/utils/interpolation.rb

@@ -1,105 +0,0 @@
-# encoding: UTF-8
-
-# Copyright 2012 Twitter, Inc
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# The implementation of the TwitterCldr.interpolate method that backports String interpolation capabilities
-# (originally implemented in String#% method) from Ruby 1.9 to Ruby 1.8 is heavily influenced by the
-# implementation of the same feature in i18n (https://github.com/svenfuchs/i18n/blob/89ea337f48562370988421e50caa7c2fe89452c7/lib/i18n/core_ext/string/interpolate.rb)
-# and gettext (https://github.com/mutoh/gettext/blob/11b8c1525ba9f00afb1942f7ebf34bec12f7558b/lib/gettext/core_ext/string.rb) gems.
-#
-# See NOTICE file for corresponding license agreements.
-
-
-# KeyError is raised during interpolation when there is a placeholder that doesn't have corresponding key in the
-# interpolation hash. KeyError is defined in 1.9. We define it for prior versions of Ruby to have the same behavior.
-#
-class KeyError < IndexError
-  def initialize(message = nil)
-    super(message || 'key not found')
-  end
-end unless defined?(KeyError)
-
-
-module TwitterCldr
-  module Utils
-
-    HASH_INTERPOLATION_REGEXP = Regexp.union(
-        /%\{(\w+)\}/,
-        /%<(\w+)>(.*?\d*\.?\d*[bBdiouxXeEfgGcps])/
-    )
-
-    HASH_INTERPOLATION_WITH_ESCAPE_REGEXP = Regexp.union(
-        /%%/,
-        HASH_INTERPOLATION_REGEXP
-    )
-
-    class << self
-
-      # Uses +string+ as a format specification and returns the result of applying it to +args+.
-      #
-      # There are three ways to use it:
-      #
-      # * Using a single argument or Array of arguments.
-      #
-      #   This is the default behaviour of the String#% method. See Kernel#sprintf for more details about the format
-      #   specification.
-      #
-      #   Example:
-      #
-      #     TwitterCldr::Utils.interpolate('%d %s', [1, 'message'])
-      #     # => "1 message"
-      #
-      # * Using a Hash as an argument and unformatted, named placeholders (Ruby 1.9 syntax).
-      #
-      #   When you pass a Hash as an argument and specify placeholders with %{foo} it will interpret the hash values as
-      #   named arguments.
-      #
-      #   Example:
-      #
-      #     TwitterCldr::Utils.interpolate('%{firstname}, %{lastname}', :firstname => 'Masao', :lastname => 'Mutoh')
-      #     # => "Masao Mutoh"
-      #
-      # * Using a Hash as an argument and formatted, named placeholders (Ruby 1.9 syntax).
-      #
-      #   When you pass a Hash as an argument and specify placeholders with %<foo>d  it will interpret the hash values
-      #   as named arguments and format the value according to the formatting instruction appended to the closing >.
-      #
-      #   Example:
-      #
-      #     TwitterCldr::Utils.interpolate('%<integer>d, %<float>.1f', :integer => 10, :float => 43.4)
-      #     # => "10, 43.3"
-      #
-      # An exception can be thrown in two cases when Ruby 1.9 interpolation syntax is used:
-      #
-      # * ArgumentError is thrown if Ruby 1.9. interpolation syntax is used in +string+, but +args+ is not a Hash;
-      # * KeyError is thrown if the value for one of the placeholders in +string+ is missing in +args+ hash.
-      #
-      def interpolate(string, args)
-        string =~ HASH_INTERPOLATION_REGEXP ? interpolate_hash(string, args) : interpolate_value_or_array(string, args)
-      end
-
-      private
-
-      def interpolate_hash(string, args)
-        raise ArgumentError.new('expected a Hash') unless args.is_a?(Hash)
-
-        string.gsub(HASH_INTERPOLATION_WITH_ESCAPE_REGEXP) do |match|
-          if match == '%%'
-            '%'
-          else
-            key = ($1 || $2).to_sym
-            raise KeyError unless args.has_key?(key)
-            $3 ? sprintf("%#{$3}", args[key]) : args[key]
-          end
-        end
-      end
-
-      def interpolate_value_or_array(string, args)
-        string.gsub(/%([{<])/, '%%\1') % args
-      end
-
-    end
-
-  end
-end