message_format 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e901569363c40dffd88d1690540f7a2bddc5aa5c
-  data.tar.gz: 64bbb73e1cfc027ec033e59a068b532763ac4d3d
+  metadata.gz: 90b4292d4e0a33c497f1cf9ec2efe3650592c900
+  data.tar.gz: 8833b184ef0771db6d1b3bebcf5e79520ec5e59e
 SHA512:
-  metadata.gz: ec37a34fe69cdf69069d6a4ae36950611ed64827577230ed8c9be6c0267ad1dbb553a2cc295c91908cae9ebb384629363a7becd1304ca58dc74b8a63a05fdc40
-  data.tar.gz: c29c673fb869551da456265b6ba2562c9884f1f11fd65f7a4af934e3a02daf8c64d8255a77c2e4ec3cee204739b2c0ab814c9e3cae278597324fe413be604f59
+  metadata.gz: a535a9ab8e3239bfcb46fe08b27fab14aacc5de742098be6e3839c0635bed11ec3c5232218220fc2b0f5c65ec9f3034bfee3806f7070a77dfdf1995b677a1521
+  data.tar.gz: 32a2459fcb0ffda22a8aa63193172558d49c2b43db209d2e6cd1d36ab629cfbd3a7a20a4310cbca8f591f3b9a92a963acf01ae32be060b48d7e5ddb60e68fda1

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 0.0.2
+
+* **New Feature**
+  * added `MessageFormat.format_message` class method
+* **Polish**
+  * better follow community style conventions
+
+## 0.0.1
+
+* Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/lib/message_format.rb

@@ -15,7 +15,7 @@ module MessageFormat
     end
 
     def format ( args=nil )
-      return @format.call(args)
+      @format.call(args)
     end
 
   end
@@ -23,7 +23,15 @@ module MessageFormat
   class << self
 
     def new ( pattern, locale=nil )
-      return MessageFormat.new(pattern, locale)
+      MessageFormat.new(pattern, locale)
+    end
+
+    def format_message ( pattern, args=nil, locale=nil )
+      locale ||= TwitterCldr.locale
+      Interpreter.interpret(
+        Parser.parse(pattern),
+        { :locale => locale.to_sym }
+      ).call(args)
     end
 
   end

data/lib/message_format/interpreter.rb

@@ -19,19 +19,19 @@ module MessageFormat
 
     def initialize ( options=nil )
       if options and options.has_key?(:locale)
-        @originalLocale = options[:locale]
+        @locale = options[:locale]
       else
-        @originalLocale = TwitterCldr.locale
+        @locale = TwitterCldr.locale
       end
     end
 
     def interpret ( elements )
-      return interpretSubs(elements)
+      interpret_subs(elements)
     end
 
-    def interpretSubs ( elements, parent=nil )
+    def interpret_subs ( elements, parent=nil )
       elements = elements.map do |element|
-        interpretElement(element, parent)
+        interpret_element(element, parent)
       end
 
       # optimize common case
@@ -39,18 +39,14 @@ module MessageFormat
         return elements[0]
       end
 
-      return lambda do |args|
-        message = ''
-        elements.map do |element|
-          message += element.call(args)
-        end
-        return message
+      lambda do |args|
+        elements.map { |element| element.call(args) }.join ''
       end
     end
 
-    def interpretElement ( element, parent=nil )
+    def interpret_element ( element, parent=nil )
       if element.is_a?(String)
-        return lambda { |args=nil| return element }
+        return lambda { |_=nil| element }
       end
 
       id, type, style = element
@@ -67,104 +63,102 @@ module MessageFormat
 
       case type
         when 'number'
-          return interpretNumber(id, offset, style)
+          interpret_number(id, offset, style)
         when 'date', 'time'
-          return interpretDateTime(id, type, style)
+          interpret_date_time(id, type, style)
         when 'plural', 'selectordinal'
           offset = element[2]
           options = element[3]
-          return interpretPlural(id, type, offset, options)
+          interpret_plural(id, type, offset, options)
         when 'select'
-          return interpretSelect(id, style)
+          interpret_select(id, style)
         when 'spellout', 'ordinal', 'duration'
-          return interpretNumber(id, offset, type)
+          interpret_number(id, offset, type)
         else
-          return interpretSimple(id)
+          interpret_simple(id)
       end
     end
 
-    def interpretNumber ( id, offset, style )
-      locale = @originalLocale
-      return lambda do |args|
+    def interpret_number ( id, offset, style )
+      locale = @locale
+      lambda do |args|
         number = TwitterCldr::Localized::LocalizedNumber.new(args[id] - offset, locale)
         if style == 'integer'
-          return number.to_decimal(:precision => 0).to_s
+          number.to_decimal(:precision => 0).to_s
         elsif style == 'percent'
-          return number.to_percent.to_s
+          number.to_percent.to_s
         elsif style == 'currency'
-          return number.to_currency.to_s
+          number.to_currency.to_s
         elsif style == 'spellout'
-          return number.spellout
+          number.spellout
         elsif style == 'ordinal'
-          return number.to_rbnf_s('OrdinalRules', 'digits-ordinal')
+          number.to_rbnf_s('OrdinalRules', 'digits-ordinal')
         else
-          return number.to_s
+          number.to_s
         end
       end
     end
 
-    def interpretDateTime ( id, type, style='medium' )
-      locale = @originalLocale
-      return lambda do |args|
+    def interpret_date_time ( id, type, style='medium' )
+      locale = @locale
+      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
+          datetime.to_medium_s
         elsif style == 'long'
-          return datetime.to_long_s
+          datetime.to_long_s
         elsif style == 'short'
-          return datetime.to_short_s
+          datetime.to_short_s
         elsif style == 'full'
-          return datetime.to_full_s
+          datetime.to_full_s
         else
-          return datetime.to_additional_s(style)
+          datetime.to_additional_s(style)
         end
       end
     end
 
-    def interpretPlural ( id, type, offset, children )
+    def interpret_plural ( id, type, offset, children )
       parent = [ id, type, offset ]
       options = {}
       children.each do |key, value|
-        options[key.to_sym] = interpretSubs(value, parent)
+        options[key.to_sym] = interpret_subs(value, parent)
       end
 
-      locale = @originalLocale
-      pluralType = type == 'selectordinal' ? :ordinal : :cardinal
-      return lambda do |args|
+      locale = @locale
+      plural_type = type == 'selectordinal' ? :ordinal : :cardinal
+      lambda do |args|
         arg = args[id]
         exactSelector = ('=' + arg.to_s).to_sym
-        keywordSelector = TwitterCldr::Formatters::Plurals::Rules.rule_for(arg - offset, locale, pluralType)
+        keywordSelector = TwitterCldr::Formatters::Plurals::Rules.rule_for(arg - offset, locale, plural_type)
         func =
           options[exactSelector] ||
           options[keywordSelector] ||
           options[:other]
-        return func.call(args)
+        func.call(args)
       end
     end
 
-    def interpretSelect ( id, children )
+    def interpret_select ( id, children )
       options = {}
       children.each do |key, value|
-        options[key.to_sym] = interpretSubs(value, nil)
+        options[key.to_sym] = interpret_subs(value, nil)
       end
-      return lambda do |args|
+      lambda do |args|
         selector = args[id].to_sym
         func =
           options[selector] ||
           options[:other]
-        return func.call(args)
+        func.call(args)
       end
     end
 
-    def interpretSimple ( id )
-      return lambda do |args|
-        return args[id].to_s
-      end
+    def interpret_simple ( id )
+      lambda { |args| args[id].to_s }
     end
 
     def self.interpret ( elements, options=nil )
-      return Interpreter.new(options).interpret(elements)
+      Interpreter.new(options).interpret(elements)
     end
 
   end

data/lib/message_format/parser.rb

@@ -26,61 +26,57 @@ module MessageFormat
 
     def parse ( pattern )
       if !pattern.is_a?(String)
-        throwExpected('String pattern', pattern.class.to_s)
+        raise_expected('String pattern', pattern.class.to_s)
       end
 
       @pattern = pattern
       @length = pattern.length
       @index = 0
-      return parseMessage("message")
+      parse_message("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'
-      )
+    def is_digit ( char )
+      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"
-      )
+    def is_whitespace ( char )
+      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])
+    def skip_whitespace ()
+      while @index < @length and is_whitespace(@pattern[@index])
         @index += 1
       end
     end
 
-    def parseText ( parentType )
-      isHashSpecial = (parentType == 'plural' or parentType == 'selectordinal')
-      isArgStyle = (parentType == 'style')
+    def parse_text ( parent_type )
+      is_hash_special = (parent_type == 'plural' or parent_type == 'selectordinal')
+      is_arg_style = (parent_type == 'style')
       text = ''
       while @index < @length
         char = @pattern[@index]
         if (
           char == '{' or
           char == '}' or
-          (isHashSpecial and char == '#') or
-          (isArgStyle and isWhitespace(char))
+          (is_hash_special and char == '#') or
+          (is_arg_style and is_whitespace(char))
         )
           break
         elsif char == '\''
@@ -93,8 +89,8 @@ module MessageFormat
             # only when necessary
             char == '{' or
             char == '}' or
-            (isHashSpecial and char == '#') or
-            (isArgStyle and isWhitespace(char))
+            (is_hash_special and char == '#') or
+            (is_arg_style and is_whitespace(char))
           )
             text += char
             while @index + 1 < @length
@@ -120,28 +116,28 @@ module MessageFormat
         end
       end
 
-      return text
+      text
     end
 
-    def parseArgument ()
+    def parse_argument ()
       if @pattern[@index] == '#'
         @index += 1 # move passed #
         return [ '#' ]
       end
 
       @index += 1 # move passed {
-      id = parseArgId()
+      id = parse_arg_id()
       char = @pattern[@index]
       if char == '}' # end argument
         @index += 1 # move passed }
         return [ id ]
       end
       if char != ','
-        throwExpected(',')
+        raise_expected(',')
       end
       @index += 1 # move passed ,
 
-      type = parseArgType()
+      type = parse_arg_type()
       char = @pattern[@index]
       if char == '}' # end argument
         if (
@@ -149,191 +145,191 @@ module MessageFormat
           type == 'selectordinal' or
           type == 'select'
         )
-          throwExpected(type + ' message options')
+          raise_expected(type + ' message options')
         end
         @index += 1 # move passed }
         return [ id, type ]
       end
       if char != ','
-        throwExpected(',')
+        raise_expected(',')
       end
       @index += 1 # move passed ,
 
       format = nil
       offset = nil
       if type == 'plural' or type == 'selectordinal'
-        offset = parsePluralOffset()
-        format = parseSubMessages(type)
+        offset = parse_plural_offset()
+        format = parse_sub_messages(type)
       elsif type == 'select'
-        format = parseSubMessages(type)
+        format = parse_sub_messages(type)
       else
-        format = parseSimpleFormat()
+        format = parse_simple_format()
       end
       char = @pattern[@index]
       if char != '}' # not ended argument
-        throwExpected('}')
+        raise_expected('}')
       end
       @index += 1 # move passed
 
-      return (type == 'plural' or type == 'selectordinal') ?
+      (type == 'plural' or type == 'selectordinal') ?
         [ id, type, offset, format ] :
         [ id, type, format ]
     end
 
-    def parseArgId ()
-      skipWhitespace()
+    def parse_arg_id ()
+      skip_whitespace()
       id = ''
       while @index < @length
         char = @pattern[@index]
         if char == '{' or char == '#'
-          throwExpected('argument id')
+          raise_expected('argument id')
         end
-        if char == '}' or char == ',' or isWhitespace(char)
+        if char == '}' or char == ',' or is_whitespace(char)
           break
         end
         id += char
         @index += 1
       end
       if id.empty?
-        throwExpected('argument id')
+        raise_expected('argument id')
       end
-      skipWhitespace()
-      return id
+      skip_whitespace()
+      id
     end
 
-    def parseArgType ()
-      skipWhitespace()
-      argType = nil
+    def parse_arg_type ()
+      skip_whitespace()
+      arg_type = nil
       types = [
         'number', 'date', 'time', 'ordinal', 'duration', 'spellout', 'plural', 'selectordinal', 'select'
       ]
       types.each do |type|
         if @pattern.slice(@index, type.length) == type
-          argType = type
+          arg_type = type
           @index += type.length
           break
         end
       end
-      if !argType
-        throwExpected(types.join(', '))
+      if !arg_type
+        raise_expected(types.join(', '))
       end
-      skipWhitespace()
-      return argType
+      skip_whitespace()
+      arg_type
     end
 
-    def parseSimpleFormat ()
-      skipWhitespace()
-      style = parseText('style')
+    def parse_simple_format ()
+      skip_whitespace()
+      style = parse_text('style')
       if style.empty?
-        throwExpected('argument style name')
+        raise_expected('argument style name')
       end
-      skipWhitespace()
-      return style
+      skip_whitespace()
+      style
     end
 
-    def parsePluralOffset ()
-      skipWhitespace()
+    def parse_plural_offset ()
+      skip_whitespace()
       offset = 0
       if @pattern.slice(@index, 7) == 'offset:'
         @index += 7 # move passed offset:
-        skipWhitespace()
+        skip_whitespace()
         start = @index
         while (
           @index < @length and
-          isDigit(@pattern[@index])
+          is_digit(@pattern[@index])
         )
           @index += 1
         end
         if start == @index
-          throwExpected('offset number')
+          raise_expected('offset number')
         end
         offset = @pattern[start..@index].to_i
-        skipWhitespace()
+        skip_whitespace()
       end
-      return offset
+      offset
     end
 
-    def parseSubMessages ( parentType )
-      skipWhitespace()
+    def parse_sub_messages ( parent_type )
+      skip_whitespace()
       options = {}
-      hasSubs = false
+      has_subs = false
       while (
         @index < @length and
         @pattern[@index] != '}'
       )
-        selector = parseSelector()
-        skipWhitespace()
-        options[selector] = parseSubMessage(parentType)
-        hasSubs = true
-        skipWhitespace()
+        selector = parse_selector()
+        skip_whitespace()
+        options[selector] = parse_sub_message(parent_type)
+        has_subs = true
+        skip_whitespace()
       end
-      if !hasSubs
-        throwExpected(parentType + ' message options')
+      if !has_subs
+        raise_expected(parent_type + ' message options')
       end
       if !options.has_key?('other') # does not have an other selector
-        throwExpected(nil, nil, '"other" option must be specified in ' + parentType)
+        raise_expected(nil, nil, '"other" option must be specified in ' + parent_type)
       end
-      return options
+      options
     end
 
-    def parseSelector ()
+    def parse_selector ()
       selector = ''
       while @index < @length
         char = @pattern[@index]
         if char == '}' or char == ','
-          throwExpected('{')
+          raise_expected('{')
         end
-        if char == '{' or isWhitespace(char)
+        if char == '{' or is_whitespace(char)
           break
         end
         selector += char
         @index += 1
       end
       if selector.empty?
-        throwExpected('selector')
+        raise_expected('selector')
       end
-      skipWhitespace()
-      return selector
+      skip_whitespace()
+      selector
     end
 
-    def parseSubMessage ( parentType )
+    def parse_sub_message ( parent_type )
       char = @pattern[@index]
       if char != '{'
-        throwExpected('{')
+        raise_expected('{')
       end
       @index += 1 # move passed {
-      message = parseMessage(parentType)
+      message = parse_message(parent_type)
       char = @pattern[@index]
       if char != '}'
-        throwExpected('}')
+        raise_expected('}')
       end
       @index += 1 # move passed }
-      return message
+      message
     end
 
-    def parseMessage ( parentType )
+    def parse_message ( parent_type )
       elements = []
-      text = parseText(parentType)
+      text = parse_text(parent_type)
       if !text.empty?
         elements.push(text)
       end
       while @index < @length
         if @pattern[@index] == '}'
-          if parentType == 'message'
-            throwExpected()
+          if parent_type == 'message'
+            raise_expected()
           end
           break
         end
-        elements.push(parseArgument())
-        text = parseText(parentType)
+        elements.push(parse_argument())
+        text = parse_text(parent_type)
         if !text.empty?
           elements.push(text)
         end
       end
-      return elements
+      elements
     end
 
-    def throwExpected ( expected=nil, found=nil, message=nil )
+    def raise_expected ( expected=nil, found=nil, message=nil )
       lines = @pattern[0..@index].split(/\r?\n/)
       line = lines.length
       column = lines.last.length
@@ -341,22 +337,21 @@ module MessageFormat
         found = @index < @length ? @pattern[@index] : 'end of input'
       end
       if !message
-        message = errorMessage(expected, found)
+        message = error_message(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 }\""
+    def error_message ( expected=nil, found )
+      expected ?
+        "Expected \"#{ expected }\" but found \"#{ found }\"" :
+        "Unexpected \"#{ found }\" found" 
     end
 
     def self.parse ( pattern )
-      return Parser.new().parse(pattern)
+      Parser.new().parse(pattern)
     end
 
     #

data/lib/message_format/version.rb

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

data/spec/message_format_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe MessageFormat do
-  describe '#new' 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
@@ -109,6 +109,29 @@ describe MessageFormat do
     end
   end
 
+  describe '.formatMessage' do
+    it 'formats messages' do
+      pattern =
+        'On {takenDate, date, short} {name} {numPeople, plural, offset:1
+            =0 {didn\'t carpool.}
+            =1 {drove himself.}
+         other {drove # people.}}'
+      message = MessageFormat.format_message(pattern,
+        :takenDate => DateTime.now,
+        :name => 'Bob',
+        :numPeople => 5
+      )
+      expect(message).to match(/^On \d\d?\/\d\d?\/\d{2,4} Bob drove 4 people.$/)
+
+      message = MessageFormat::format_message(pattern,
+        :takenDate => DateTime.now,
+        :name => 'Bill',
+        :numPeople => 6
+      )
+      expect(message).to match(/^On \d\d?\/\d\d?\/\d{2,4} Bill drove 5 people.$/)
+    end
+  end
+
   describe 'locales' do
     it 'doesn\'t throw for any locale\'s plural function' do
       pattern =

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: message_format
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Andy VanWagoner
@@ -62,6 +62,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md