message_format 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e901569363c40dffd88d1690540f7a2bddc5aa5c
+  data.tar.gz: 64bbb73e1cfc027ec033e59a068b532763ac4d3d
+SHA512:
+  metadata.gz: ec37a34fe69cdf69069d6a4ae36950611ed64827577230ed8c9be6c0267ad1dbb553a2cc295c91908cae9ebb384629363a7becd1304ca58dc74b8a63a05fdc40
+  data.tar.gz: c29c673fb869551da456265b6ba2562c9884f1f11fd65f7a4af934e3a02daf8c64d8255a77c2e4ec3cee204739b2c0ab814c9e3cae278597324fe413be604f59

data/.gitignore

@@ -0,0 +1,40 @@
+# ignore system files
+
+# OS X
+.DS_Store
+.Spotlight-V100
+.Trashes
+._*
+
+# Win
+Thumbs.db
+Desktop.ini
+
+# vim
+*~
+.swp
+.*.sw[a-z]
+Session.vim
+
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in message_format.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Andy VanWagoner
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# MessageFormat
+
+Parse and format i18n messages using ICU MessageFormat patterns
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'message_format'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install message_format
+
+## Usage
+
+```ruby
+require 'message_format'
+
+message = MessageFormat.new('Hello { place }!', 'en-US')
+formatted = message.format({ :place => 'World' })
+```
+
+The [ICU Message Format][icu-message] is a great format for user-visible strings, and includes simple placeholders, number and date placeholders, and selecting among submessages for gender and plural arguments. The format is used in apis in [C++][icu-cpp], [PHP][icu-php], [Java][icu-java], and [JavaScript][icu-javascript].
+
+## Contributing
+
+1. Fork it ( https://github.com/thetalecrafter/message-format-rb/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License
+
+This software is free to use under the MIT license. See the [LICENSE.txt file][LICENSE] for license text and copyright information.
+
+[icu-message]: http://userguide.icu-project.org/formatparse/messages
+[icu-cpp]: http://icu-project.org/apiref/icu4c/classicu_1_1MessageFormat.html
+[icu-php]: http://php.net/manual/en/class.messageformatter.php
+[icu-java]: http://icu-project.org/apiref/icu4j/
+[icu-javascript]: https://github.com/thetalecrafter/message-format
+[LICENSE]: https://github.com/thetalecrafter/message-format-rb/blob/master/LICENSE.txt

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/benchmark.rb

@@ -0,0 +1,73 @@
+require 'benchmark'
+require_relative 'lib/message_format'
+
+iterations = 100_000
+
+Benchmark.bm do |bm|
+  bm.report('parse simple message') do
+    parser = MessageFormat::Parser.new()
+    iterations.times do
+      parser.parse("I'm a super simple message")
+    end
+  end
+
+  bm.report('format simple message') do
+    message = MessageFormat.new("I'm a super simple message")
+    iterations.times do
+      message.format()
+    end
+  end
+
+  bm.report('parse one arg message') do
+    parser = MessageFormat::Parser.new()
+    iterations.times do
+      parser.parse("I'm a { arg } message")
+    end
+  end
+
+  bm.report('format one arg message') do
+    message = MessageFormat.new("I'm a { arg } message")
+    iterations.times do
+      message.format({ :arg => 'awesome' })
+    end
+  end
+
+  bm.report('parse complex message') do
+    parser = MessageFormat::Parser.new()
+    iterations.times do
+      parser.parse('On {day, date, short} {
+  count, plural, offset:1
+     =0 {nobody carpooled.}
+     =1 {{driverName} drove {
+      driverGender, select,
+        male {himself}
+      female {herself}
+       other {themself}
+    }.}
+  other {{driverName} drove # people.}
+}')
+    end
+  end
+
+  bm.report('format complex message') do
+    message = MessageFormat.new('On {day, date, short} {
+  count, plural, offset:1
+     =0 {nobody carpooled.}
+     =1 {{driverName} drove {
+      driverGender, select,
+        male {himself}
+      female {herself}
+       other {themself}
+    }.}
+  other {{driverName} drove # people.}
+}')
+    iterations.times do
+      message.format({
+  :day => DateTime.now,
+  :count => 5,
+  :driverName => 'Jeremy',
+  :driverGender => 'male'
+})
+    end
+  end
+end

data/lib/message_format.rb

@@ -0,0 +1,30 @@
+require 'twitter_cldr'
+require_relative 'message_format/version'
+require_relative 'message_format/parser'
+require_relative 'message_format/interpreter'
+
+module MessageFormat
+  class MessageFormat
+
+    def initialize ( pattern, locale=nil )
+      @locale = (locale || TwitterCldr.locale).to_sym
+      @format = Interpreter.interpret(
+        Parser.parse(pattern),
+        { :locale => @locale }
+      )
+    end
+
+    def format ( args=nil )
+      return @format.call(args)
+    end
+
+  end
+
+  class << self
+
+    def new ( pattern, locale=nil )
+      return MessageFormat.new(pattern, locale)
+    end
+
+  end
+end

data/lib/message_format/interpreter.rb

@@ -0,0 +1,171 @@
+require 'twitter_cldr'
+
+#
+# Interpreter
+#
+# Turns this:
+#  [ "You have ", [ "numBananas", "plural", 0, {
+#       "=0": [ "no bananas" ],
+#      "one": [ "a banana" ],
+#    "other": [ [ '#' ], " bananas" ]
+#  } ], " for sale." ]
+#
+# into this:
+#  format({ numBananas:0 })
+#  "You have no bananas for sale."
+#
+module MessageFormat
+  class Interpreter
+
+    def initialize ( options=nil )
+      if options and options.has_key?(:locale)
+        @originalLocale = options[:locale]
+      else
+        @originalLocale = TwitterCldr.locale
+      end
+    end
+
+    def interpret ( elements )
+      return interpretSubs(elements)
+    end
+
+    def interpretSubs ( elements, parent=nil )
+      elements = elements.map do |element|
+        interpretElement(element, parent)
+      end
+
+      # optimize common case
+      if elements.length == 1
+        return elements[0]
+      end
+
+      return lambda do |args|
+        message = ''
+        elements.map do |element|
+          message += element.call(args)
+        end
+        return message
+      end
+    end
+
+    def interpretElement ( element, parent=nil )
+      if element.is_a?(String)
+        return lambda { |args=nil| return element }
+      end
+
+      id, type, style = element
+      offset = 0
+
+      if id == '#'
+        id = parent[0]
+        type = 'number'
+        offset = parent[2] || 0
+        style = nil
+      end
+
+      id = id.to_sym # actual arguments should always be keyed by symbols
+
+      case type
+        when 'number'
+          return interpretNumber(id, offset, style)
+        when 'date', 'time'
+          return interpretDateTime(id, type, style)
+        when 'plural', 'selectordinal'
+          offset = element[2]
+          options = element[3]
+          return interpretPlural(id, type, offset, options)
+        when 'select'
+          return interpretSelect(id, style)
+        when 'spellout', 'ordinal', 'duration'
+          return interpretNumber(id, offset, type)
+        else
+          return interpretSimple(id)
+      end
+    end
+
+    def interpretNumber ( id, offset, style )
+      locale = @originalLocale
+      return lambda do |args|
+        number = TwitterCldr::Localized::LocalizedNumber.new(args[id] - offset, locale)
+        if style == 'integer'
+          return number.to_decimal(:precision => 0).to_s
+        elsif style == 'percent'
+          return number.to_percent.to_s
+        elsif style == 'currency'
+          return number.to_currency.to_s
+        elsif style == 'spellout'
+          return number.spellout
+        elsif style == 'ordinal'
+          return number.to_rbnf_s('OrdinalRules', 'digits-ordinal')
+        else
+          return number.to_s
+        end
+      end
+    end
+
+    def interpretDateTime ( id, type, style='medium' )
+      locale = @originalLocale
+      return lambda do |args|
+        datetime = TwitterCldr::Localized::LocalizedDateTime.new(args[id], locale)
+        datetime = type == 'date' ? datetime.to_date : datetime.to_time
+        if style == 'medium'
+          return datetime.to_medium_s
+        elsif style == 'long'
+          return datetime.to_long_s
+        elsif style == 'short'
+          return datetime.to_short_s
+        elsif style == 'full'
+          return datetime.to_full_s
+        else
+          return datetime.to_additional_s(style)
+        end
+      end
+    end
+
+    def interpretPlural ( id, type, offset, children )
+      parent = [ id, type, offset ]
+      options = {}
+      children.each do |key, value|
+        options[key.to_sym] = interpretSubs(value, parent)
+      end
+
+      locale = @originalLocale
+      pluralType = type == 'selectordinal' ? :ordinal : :cardinal
+      return lambda do |args|
+        arg = args[id]
+        exactSelector = ('=' + arg.to_s).to_sym
+        keywordSelector = TwitterCldr::Formatters::Plurals::Rules.rule_for(arg - offset, locale, pluralType)
+        func =
+          options[exactSelector] ||
+          options[keywordSelector] ||
+          options[:other]
+        return func.call(args)
+      end
+    end
+
+    def interpretSelect ( id, children )
+      options = {}
+      children.each do |key, value|
+        options[key.to_sym] = interpretSubs(value, nil)
+      end
+      return lambda do |args|
+        selector = args[id].to_sym
+        func =
+          options[selector] ||
+          options[:other]
+        return func.call(args)
+      end
+    end
+
+    def interpretSimple ( id )
+      return lambda do |args|
+        return args[id].to_s
+      end
+    end
+
+    def self.interpret ( elements, options=nil )
+      return Interpreter.new(options).interpret(elements)
+    end
+
+  end
+end

data/lib/message_format/parser.rb

@@ -0,0 +1,387 @@
+#
+# Parser
+#
+# Turns this:
+#  `You have { numBananas, plural,
+#       =0 {no bananas}
+#      one {a banana}
+#    other {# bananas}
+#  } for sale`
+#
+# into this:
+#  [ "You have ", [ "numBananas", "plural", 0, {
+#       "=0": [ "no bananas" ],
+#      "one": [ "a banana" ],
+#    "other": [ [ '#' ], " bananas" ]
+#  } ], " for sale." ]
+#
+module MessageFormat
+  class Parser
+
+    def initialize ()
+      @pattern = nil
+      @length = 0
+      @index = 0
+    end
+
+    def parse ( pattern )
+      if !pattern.is_a?(String)
+        throwExpected('String pattern', pattern.class.to_s)
+      end
+
+      @pattern = pattern
+      @length = pattern.length
+      @index = 0
+      return parseMessage("message")
+    end
+
+    def isDigit ( char )
+      return (
+        char == '0' or
+        char == '1' or
+        char == '2' or
+        char == '3' or
+        char == '4' or
+        char == '5' or
+        char == '6' or
+        char == '7' or
+        char == '8' or
+        char == '9'
+      )
+    end
+
+    def isWhitespace ( char )
+      return (
+        char == "\s" or
+        char == "\t" or
+        char == "\n" or
+        char == "\r" or
+        char == "\f" or
+        char == "\v" or
+        char == "\u00A0" or
+        char == "\u2028" or
+        char == "\u2029"
+      )
+    end
+
+    def skipWhitespace ()
+      while @index < @length and isWhitespace(@pattern[@index])
+        @index += 1
+      end
+    end
+
+    def parseText ( parentType )
+      isHashSpecial = (parentType == 'plural' or parentType == 'selectordinal')
+      isArgStyle = (parentType == 'style')
+      text = ''
+      while @index < @length
+        char = @pattern[@index]
+        if (
+          char == '{' or
+          char == '}' or
+          (isHashSpecial and char == '#') or
+          (isArgStyle and isWhitespace(char))
+        )
+          break
+        elsif char == '\''
+          @index += 1
+          char = @pattern[@index]
+          if char == '\'' # double is always 1 '
+            text += char
+            @index += 1
+          elsif (
+            # only when necessary
+            char == '{' or
+            char == '}' or
+            (isHashSpecial and char == '#') or
+            (isArgStyle and isWhitespace(char))
+          )
+            text += char
+            while @index + 1 < @length
+              @index += 1
+              char = @pattern[@index]
+              if @pattern.slice(@index, 2) == '\'\'' # double is always 1 '
+                text += char
+                @index += 1
+              elsif char == '\'' # end of quoted
+                @index += 1
+                break
+              else
+                text += char
+              end
+            end
+          else # lone ' is just a '
+            text += '\''
+            # already incremented
+          end
+        else
+          text += char
+          @index += 1
+        end
+      end
+
+      return text
+    end
+
+    def parseArgument ()
+      if @pattern[@index] == '#'
+        @index += 1 # move passed #
+        return [ '#' ]
+      end
+
+      @index += 1 # move passed {
+      id = parseArgId()
+      char = @pattern[@index]
+      if char == '}' # end argument
+        @index += 1 # move passed }
+        return [ id ]
+      end
+      if char != ','
+        throwExpected(',')
+      end
+      @index += 1 # move passed ,
+
+      type = parseArgType()
+      char = @pattern[@index]
+      if char == '}' # end argument
+        if (
+          type == 'plural' or
+          type == 'selectordinal' or
+          type == 'select'
+        )
+          throwExpected(type + ' message options')
+        end
+        @index += 1 # move passed }
+        return [ id, type ]
+      end
+      if char != ','
+        throwExpected(',')
+      end
+      @index += 1 # move passed ,
+
+      format = nil
+      offset = nil
+      if type == 'plural' or type == 'selectordinal'
+        offset = parsePluralOffset()
+        format = parseSubMessages(type)
+      elsif type == 'select'
+        format = parseSubMessages(type)
+      else
+        format = parseSimpleFormat()
+      end
+      char = @pattern[@index]
+      if char != '}' # not ended argument
+        throwExpected('}')
+      end
+      @index += 1 # move passed
+
+      return (type == 'plural' or type == 'selectordinal') ?
+        [ id, type, offset, format ] :
+        [ id, type, format ]
+    end
+
+    def parseArgId ()
+      skipWhitespace()
+      id = ''
+      while @index < @length
+        char = @pattern[@index]
+        if char == '{' or char == '#'
+          throwExpected('argument id')
+        end
+        if char == '}' or char == ',' or isWhitespace(char)
+          break
+        end
+        id += char
+        @index += 1
+      end
+      if id.empty?
+        throwExpected('argument id')
+      end
+      skipWhitespace()
+      return id
+    end
+
+    def parseArgType ()
+      skipWhitespace()
+      argType = nil
+      types = [
+        'number', 'date', 'time', 'ordinal', 'duration', 'spellout', 'plural', 'selectordinal', 'select'
+      ]
+      types.each do |type|
+        if @pattern.slice(@index, type.length) == type
+          argType = type
+          @index += type.length
+          break
+        end
+      end
+      if !argType
+        throwExpected(types.join(', '))
+      end
+      skipWhitespace()
+      return argType
+    end
+
+    def parseSimpleFormat ()
+      skipWhitespace()
+      style = parseText('style')
+      if style.empty?
+        throwExpected('argument style name')
+      end
+      skipWhitespace()
+      return style
+    end
+
+    def parsePluralOffset ()
+      skipWhitespace()
+      offset = 0
+      if @pattern.slice(@index, 7) == 'offset:'
+        @index += 7 # move passed offset:
+        skipWhitespace()
+        start = @index
+        while (
+          @index < @length and
+          isDigit(@pattern[@index])
+        )
+          @index += 1
+        end
+        if start == @index
+          throwExpected('offset number')
+        end
+        offset = @pattern[start..@index].to_i
+        skipWhitespace()
+      end
+      return offset
+    end
+
+    def parseSubMessages ( parentType )
+      skipWhitespace()
+      options = {}
+      hasSubs = false
+      while (
+        @index < @length and
+        @pattern[@index] != '}'
+      )
+        selector = parseSelector()
+        skipWhitespace()
+        options[selector] = parseSubMessage(parentType)
+        hasSubs = true
+        skipWhitespace()
+      end
+      if !hasSubs
+        throwExpected(parentType + ' message options')
+      end
+      if !options.has_key?('other') # does not have an other selector
+        throwExpected(nil, nil, '"other" option must be specified in ' + parentType)
+      end
+      return options
+    end
+
+    def parseSelector ()
+      selector = ''
+      while @index < @length
+        char = @pattern[@index]
+        if char == '}' or char == ','
+          throwExpected('{')
+        end
+        if char == '{' or isWhitespace(char)
+          break
+        end
+        selector += char
+        @index += 1
+      end
+      if selector.empty?
+        throwExpected('selector')
+      end
+      skipWhitespace()
+      return selector
+    end
+
+    def parseSubMessage ( parentType )
+      char = @pattern[@index]
+      if char != '{'
+        throwExpected('{')
+      end
+      @index += 1 # move passed {
+      message = parseMessage(parentType)
+      char = @pattern[@index]
+      if char != '}'
+        throwExpected('}')
+      end
+      @index += 1 # move passed }
+      return message
+    end
+
+    def parseMessage ( parentType )
+      elements = []
+      text = parseText(parentType)
+      if !text.empty?
+        elements.push(text)
+      end
+      while @index < @length
+        if @pattern[@index] == '}'
+          if parentType == 'message'
+            throwExpected()
+          end
+          break
+        end
+        elements.push(parseArgument())
+        text = parseText(parentType)
+        if !text.empty?
+          elements.push(text)
+        end
+      end
+      return elements
+    end
+
+    def throwExpected ( expected=nil, found=nil, message=nil )
+      lines = @pattern[0..@index].split(/\r?\n/)
+      line = lines.length
+      column = lines.last.length
+      if !found
+        found = @index < @length ? @pattern[@index] : 'end of input'
+      end
+      if !message
+        message = errorMessage(expected, found)
+      end
+      message += ' in "' + @pattern.gsub(/\r?\n/, "\n") + '"'
+
+      raise SyntaxError.new(message, expected, found, @index, line, column)
+    end
+
+    def errorMessage ( expected=nil, found )
+      if !expected
+        return "Unexpected \"#{ found }\" found"
+      end
+      return "Expected \"#{ expected }\" but found \"#{ found }\""
+    end
+
+    def self.parse ( pattern )
+      return Parser.new().parse(pattern)
+    end
+
+    #
+    # Syntax Error
+    #  Holds information about bad syntax found in a message pattern
+    #
+    class SyntaxError < StandardError
+
+      attr_reader :message
+      attr_reader :expected
+      attr_reader :found
+      attr_reader :offset
+      attr_reader :line
+      attr_reader :column
+
+      def initialize (message, expected, found, offset, line, column)
+        @message = message
+        @expected = expected
+        @found = found
+        @offset = offset
+        @line = line
+        @column = column
+      end
+
+    end
+
+  end
+end

data/lib/message_format/version.rb

@@ -0,0 +1,3 @@
+module MessageFormat
+  VERSION = "0.0.1"
+end

data/message_format.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'message_format/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "message_format"
+  spec.version       = MessageFormat::VERSION
+  spec.authors       = ["Andy VanWagoner"]
+  spec.email         = ["andy@instructure.com"]
+  spec.summary       = %q{Parse and format i18n messages using ICU MessageFormat patterns}
+  spec.description   = %q{Parse and format i18n messages using ICU MessageFormat patterns, including simple placeholders, number and date placeholders, and selecting among submessages for gender and plural arguments.}
+  spec.homepage      = "https://github.com/thetalecrafter/message-format-rb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "twitter_cldr", "~> 3.1"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/spec/message_format_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe MessageFormat do
+  describe '#new' do
+    it 'throws an error on bad syntax' do
+      expect { MessageFormat.new({}) }.to raise_error
+      expect { MessageFormat.new('no finish arg {') }.to raise_error
+      expect { MessageFormat.new('no start arg }') }.to raise_error
+      expect { MessageFormat.new('empty arg {}') }.to raise_error
+      expect { MessageFormat.new('unfinished select { a, select }') }.to raise_error
+      expect { MessageFormat.new('unfinished select { a, select, }') }.to raise_error
+      expect { MessageFormat.new('sub with no selector { a, select, {hi} }') }.to raise_error
+      expect { MessageFormat.new('sub with no other { a, select, foo {hi} }') }.to raise_error
+      expect { MessageFormat.new('wrong escape \\{') }.to raise_error
+      expect { MessageFormat.new('wrong escape \'{\'', 'en', { escape: '\\' }) }.to raise_error
+      expect { MessageFormat.new('bad arg type { a, bogus, nope }') }.to raise_error
+      expect { MessageFormat.new('bad arg separator { a bogus, nope }') }.to raise_error
+    end
+  end
+
+  describe '#format' do
+    it 'formats a simple message' do
+      pattern = 'Simple string with nothing special'
+      message = MessageFormat.new(pattern, 'en-US').format()
+
+      expect(message).to eql('Simple string with nothing special')
+    end
+
+    it 'handles pattern with escaped text' do
+      pattern = 'This isn\'\'t a \'{\'\'simple\'\'}\' \'string\''
+      message = MessageFormat.new(pattern, 'en-US').format()
+
+      expect(message).to eql('This isn\'t a {\'simple\'} \'string\'')
+    end
+
+    it 'accepts arguments' do
+      pattern = 'x{ arg }z'
+      message = MessageFormat.new(pattern, 'en-US').format({ :arg => 'y' })
+
+      expect(message).to eql('xyz')
+    end
+
+    it 'formats numbers, dates, and times' do
+      pattern = '{ n, number } : { d, date, short } { d, time, short }'
+      message = MessageFormat.new(pattern, 'en-US').format({ :n => 0, :d => DateTime.new(0) })
+
+      expect(message).to match(/^0 \: \d\d?\/\d\d?\/\d{2,4} \d\d?\:\d\d [AP]M$/)
+    end
+
+    it 'handles plurals' do
+      pattern =
+        'On {takenDate, date, short} {name} {numPeople, plural, offset:1
+            =0 {didn\'t carpool.}
+            =1 {drove himself.}
+         other {drove # people.}}'
+      message = MessageFormat.new(pattern, 'en-US')
+          .format({ :takenDate => DateTime.now, :name => 'Bob', :numPeople => 5 })
+
+      expect(message).to match(/^On \d\d?\/\d\d?\/\d{2,4} Bob drove 4 people.$/)
+    end
+
+    it 'handles plurals for other locales' do
+      pattern =
+        '{n, plural,
+          zero {zero}
+           one {one}
+           two {two}
+           few {few}
+          many {many}
+         other {other}}'
+      message = MessageFormat.new(pattern, 'ar')
+
+      expect(message.format({ n: 0 })).to eql('zero')
+      expect(message.format({ n: 1 })).to eql('one')
+      expect(message.format({ n: 2 })).to eql('two')
+      expect(message.format({ n: 3 })).to eql('few')
+      expect(message.format({ n: 11 })).to eql('many')
+    end
+
+    it 'handles selectordinals' do
+      pattern =
+        '{n, selectordinal,
+           one {#st}
+           two {#nd}
+           few {#rd}
+         other {#th}}'
+      message = MessageFormat.new(pattern, 'en')
+
+      expect(message.format({ n: 1 })).to eql('1st')
+      expect(message.format({ n: 22 })).to eql('22nd')
+      expect(message.format({ n: 103 })).to eql('103rd')
+      expect(message.format({ n: 4 })).to eql('4th')
+    end
+
+    it 'handles select' do
+      pattern =
+        '{ gender, select,
+           male {it\'s his turn}
+         female {it\'s her turn}
+          other {it\'s their turn}}'
+      message = MessageFormat.new(pattern, 'en-US')
+          .format({ gender: 'female' })
+
+      expect(message).to eql('it\'s her turn')
+    end
+
+    it 'should throw an error when args are expected and not passed' do
+      expect { MessageFormat.new('{a}').format() }.to raise_error
+    end
+  end
+
+  describe 'locales' do
+    it 'doesn\'t throw for any locale\'s plural function' do
+      pattern =
+        '{n, plural,
+          zero {zero}
+           one {one}
+           two {two}
+           few {few}
+          many {many}
+         other {other}}'
+      TwitterCldr.supported_locales.each do |locale|
+        message = MessageFormat.new(pattern, locale)
+        for n in 0..200 do
+          result = message.format({ :n => n })
+          expect(result).to match(/^(zero|one|two|few|many|other)$/)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/message_format'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: message_format
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andy VanWagoner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: twitter_cldr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Parse and format i18n messages using ICU MessageFormat patterns, including
+  simple placeholders, number and date placeholders, and selecting among submessages
+  for gender and plural arguments.
+email:
+- andy@instructure.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark.rb
+- lib/message_format.rb
+- lib/message_format/interpreter.rb
+- lib/message_format/parser.rb
+- lib/message_format/version.rb
+- message_format.gemspec
+- spec/message_format_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/thetalecrafter/message-format-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.2
+signing_key: 
+specification_version: 4
+summary: Parse and format i18n messages using ICU MessageFormat patterns
+test_files:
+- spec/message_format_spec.rb
+- spec/spec_helper.rb
+has_rdoc: