cldr-plurals 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8f030dac2488f8587a8c08bb417020586fbf8fb1
+  data.tar.gz: 6a8e9b73402a09d1d784639a369b6f22730d30e9
+SHA512:
+  metadata.gz: ac49b1952414dd79e8d5cef92aec0916e8815c29c2a3e354eaf807a26a022af32a09f35cdd12d816c131c3d0d488a07b22caedb9f2f74b452ebae058ac661247
+  data.tar.gz: e97db6ef1351a1873aea7e0d1c893008e5f4131e1b84f922c6afa03d2563d8b065aab48846276b7f25d6378ae2c6e95836298efcd5691a8a9b30f981f57331fe

data/Gemfile

@@ -0,0 +1,18 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem 'pry-nav'
+  gem 'rake'
+  gem 'nokogiri'
+end
+
+group :test do
+  gem 'rspec'
+  gem 'rr'
+
+  gem 'therubyracer', '~> 0.12.0'
+  gem 'cldr-plurals-runtime-rb', '~> 1.0.0'
+  gem 'cldr-plurals-runtime-js', '~> 1.0.0'
+end

data/History.txt

@@ -0,0 +1,3 @@
+== 1.0.0
+
+* Birthday!

data/README.md

@@ -0,0 +1,139 @@
+cldr-plurals
+=================
+
+[![Build Status](https://travis-ci.org/camertron/cldr-plurals.svg?branch=master)](http://travis-ci.org/camertron/cldr-plurals)
+
+Tokenizes and parses CLDR plural rules and provides a mechanism for emitting them as source code.
+
+## Installation
+
+`gem install cldr-plurals`
+
+## Usage
+
+```ruby
+require 'cldr-plurals'
+```
+
+## Rules
+
+The CLDR data set contains [plural information](http://unicode.org/cldr/trac/browser/tags/release-26-d04/common/supplemental/plurals.xml) for numerous languages in an expression-based [format](http://www.unicode.org/reports/tr35/tr35-numbers.html#Language_Plural_Rules) defined by Unicode's TR35. This gem can tokenize, parse, and emit these rules as source code. Currently Ruby and Javascript are supported.
+
+### Tokenizing
+
+Generate a list of tokens using the `Tokenizer` class:
+
+```ruby
+tokens = CldrPlurals::Compiler::Tokenizer.tokenize(
+  'v = 0 and i % 10 = 1 and i % 100 != 11'
+)
+```
+
+### Parsing
+
+Once you have a token list, the `Parser` class can turn them into an [abstract syntax tree](http://en.wikipedia.org/wiki/Abstract_syntax_tree), (i.e a `CldrPlurals::Compiler::Rule`) for you:
+
+```ruby
+rule = CldrPlurals::Compiler::Parser.new(tokens).parse
+```
+
+### Emitting
+
+Rules can be emitted as either Ruby or Javascript source code via the appropriate `Emitter` class:
+
+```ruby
+ruby_code = CldrPlurals::RubyEmitter.emit_rule_standalone(rule)
+```
+
+For our example above, the emitted standalone ruby code looks like this:
+
+```ruby
+lambda { |n, i, f, t, v, w| ((v == 0 && i % 10 == 1) && i % 100 != 11) }
+```
+
+## Rule Lists
+
+The CLDR data set defines groups of rules that together determine the plural form for a given number. Create a `RuleList` object to group rules together. `RuleList`s take care of the tokenizing and parsing steps for you:
+
+```ruby
+rules = CldrPlurals::Compiler::RuleList.new(:ru).tap do |rule_list|
+  rule_list.add_rule(:one, 'v = 0 and i % 10 = 1 and i % 100 != 11')
+  rule_list.add_rule(:few, 'v = 0 and i % 10 = 2..4 and i % 100 != 12..14')
+  rule_list.add_rule(:many, 'v = 0 and i % 10 = 0 or v = 0 and i % 10 = 5..9 or v = 0 and i % 100 = 11..14')
+end
+```
+
+Note that there's no need to add an explicit rule for the `other` plural form.
+
+`RuleList`s can be emitted in their entirety via the `to_code` method, which accepts a target language as an argument:
+
+```ruby
+rules.to_code(:ruby)
+```
+
+Which produces:
+
+```ruby
+lambda { |num, runtime| n = runtime.n(num); i = runtime.i(num); v = runtime.v(num); w = runtime.w(num); f = runtime.f(num); t = runtime.t(num); (((v == 0 && i % 10 == 1) && i % 100 != 11) ? :one : (((v == 0 && (2..4).include?(i % 10)) && !(12..14).include?(i % 100)) ? :few : ((((v == 0 && i % 10 == 0) || (v == 0 && (5..9).include?(i % 10))) || (v == 0 && (11..14).include?(i % 100))) ? :many : :other))) }
+```
+
+OR
+
+```ruby
+rules.to_code(:javascript)
+```
+
+Which produces:
+
+```javascript
+(function(num, runtime) { var n = runtime.n(num); var i = runtime.i(num); var v = runtime.v(num); var w = runtime.w(num); var f = runtime.f(num); var t = runtime.t(num); return (((v == 0 && i % 10 == 1) && i % 100 != 11) ? 'one' : (((v == 0 && ((i % 10 >= 2) && (i % 10 <= 4))) && !((i % 100 >= 12) && (i % 100 <= 14))) ? 'few' : ((((v == 0 && i % 10 == 0) || (v == 0 && ((i % 10 >= 5) && (i % 10 <= 9)))) || (v == 0 && ((i % 100 >= 11) && (i % 100 <= 14)))) ? 'many' : 'other'))); })
+```
+
+## Executing Targets
+
+You may have noticed that emitted target source code requires a runtime (the second argument). Runtimes provide methods to determine the 'parts' of a number, like the decimal portion or the number of decimals without trailing zeroes. Runtimes for [Ruby](https://github.com/camertron/cldr-plurals-runtime-rb) and [Javascript](https://github.com/camertron/cldr-plurals-runtime-js) exist as separate rubygems, so you'll need to include them in your project before being able to execute target code. Each runtime gem's README contains instructions on how to use it. Here are some quick examples:
+
+Ruby:
+
+```ruby
+# construct RuleList...
+
+require 'cldr-plurals/ruby_runtime'
+
+ruby_code = rules.to_code(:ruby)
+plural_proc = eval(ruby_code)
+
+plural_proc.call('3', CldrPlurals::RubyRuntime)  # => :few
+```
+
+Javascript:
+
+```ruby
+# construct RuleList...
+
+require 'cldr-plurals/javascript_runtime'
+
+plural_code = rules.to_code(:javascript)
+
+File.open('./plurals-ru.js', 'w+') do |f|
+  f.write("
+    var runtime = #{CldrPlurals::JavascriptRuntime.source};
+    var rules = #{plural_code};
+    console.log(rules('3', runtime));
+  ")
+end
+```
+
+Then, running `node ./plurals-ru.js` should print `'few'`.
+
+## Requirements
+
+No external requirements.
+
+## Running Tests
+
+`bundle exec rake` should do the trick. Alternatively you can run `bundle exec rspec`, which does the same thing.
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/Rakefile

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require './lib/cldr-plurals'
+
+Bundler::GemHelper.install_tasks
+
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end
+
+def expand_sample_range(sample_range)
+  first, last = sample_range.split('~')
+
+  if decimal_idx = first.index('.')
+    decimal = first[(decimal_idx + 1)..-1]
+    increment = 1.0 / (10 ** decimal.length)
+    current = first.to_f
+    last_f = last.to_f
+    results = []
+
+    while current <= last_f
+      results << current.to_s
+      current = (current + increment).round(decimal.length)
+    end
+
+    results
+  else
+    (first.to_i..last.to_i).to_a.map(&:to_s)
+  end
+end
+
+def expand_samples(sample_str)
+  sample_str.split(', ').flat_map do |sample_chunk|
+    if sample_chunk.include?('~')
+      expand_sample_range(sample_chunk)
+    else
+      [sample_chunk]
+    end
+  end
+end
+
+task :update_samples do
+  require 'open-uri'
+  require 'nokogiri'
+  require 'yaml'
+
+  url = 'http://unicode.org/cldr/trac/browser/tags/release-26-d04/' +
+    'common/supplemental/plurals.xml?format=txt'
+
+  doc = Nokogiri::XML(open(url).read)
+
+  samples = (doc / 'pluralRules').each_with_object({}) do |rules, ret|
+    locales = rules.attributes['locales'].value.split(' ').join('/')
+
+    ret[locales] = (rules / 'pluralRule').map do |rule|
+      chunks = rule.text.split(/(@integer|@decimal)/)
+      name = rule.attributes['count'].value.to_sym
+
+      {
+        text: chunks.first.strip,
+        name: name,
+        samples: chunks[1..-1].each_slice(2).map do |slice|
+          {
+            type: slice.first.strip,
+            samples: expand_samples(slice.last.strip.chomp(', …'))
+          }
+        end
+      }
+    end
+  end
+
+  File.open(File.join(File.dirname(__FILE__), 'spec/samples.yml'), 'w+') do |f|
+    f.write(YAML.dump(samples))
+  end
+end

data/cldr-plurals.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'cldr-plurals/version'
+
+Gem::Specification.new do |s|
+  s.name     = "cldr-plurals"
+  s.version  = ::CldrPlurals::VERSION
+  s.authors  = ["Cameron Dutro"]
+  s.email    = ["camertron@gmail.com"]
+  s.homepage = "http://github.com/camertron"
+
+  s.description = s.summary = 'Tokenizes and parses CLDR plural rules and provides a mechanism for emitting them as source code'
+
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+
+  s.require_path = 'lib'
+  s.files = Dir["{lib,spec}/**/*", "Gemfile", "History.txt", "README.md", "Rakefile", "cldr-plurals.gemspec"]
+end

data/lib/cldr-plurals.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+
+module CldrPlurals
+  autoload :Compiler,          'cldr-plurals/compiler'
+  autoload :RubyEmitter,       'cldr-plurals/ruby_emitter'
+  autoload :JavascriptEmitter, 'cldr-plurals/javascript_emitter'
+end

data/lib/cldr-plurals/compiler.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+
+module CldrPlurals
+  module Compiler
+    autoload :Tokenizer, 'cldr-plurals/compiler/tokenizer'
+    autoload :Parser,    'cldr-plurals/compiler/parser'
+    autoload :Emitter,   'cldr-plurals/compiler/emitter'
+
+    class RuleList
+      attr_reader :locale, :rules
+
+      def initialize(locale)
+        @locale = locale
+        @rules = []
+      end
+
+      def add_rule(name, rule_string)
+        rule = Parser.new(Tokenizer.tokenize(rule_string)).parse
+        rule.name = name
+        rules << rule
+        nil
+      end
+
+      def to_code(prog_lang)
+        emitter = find_emitter(prog_lang)
+        emitter.emit_rules(self)
+      end
+
+      private
+
+      def find_emitter(prog_lang)
+        lang = prog_lang.to_s.gsub(/(^\w|[-_]\w)/) { $1[-1].upcase }
+        const_name = "#{lang}Emitter"
+
+        if CldrPlurals.const_defined?(const_name)
+          CldrPlurals.const_get(const_name)
+        else
+          raise ArgumentError, "emitter '#{lang}::#{const_name}' not found."
+        end
+      end
+    end
+  end
+end

data/lib/cldr-plurals/compiler/emitter.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+module CldrPlurals
+  module Compiler
+    class Emitter
+      class << self
+
+        protected
+
+        def emit(obj)
+          name = obj.class.name
+            .split('::').last
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .downcase
+
+          method_sym = :"emit_#{name}"
+
+          if respond_to?(method_sym, true)
+            send(method_sym, obj)
+          end
+        end
+
+        def emit_all(*objs)
+          objs.map { |obj| emit(obj) }
+        end
+
+      end
+    end
+  end
+end

data/lib/cldr-plurals/compiler/nodes.rb

@@ -0,0 +1,86 @@
+# encoding: UTF-8
+
+module CldrPlurals
+  module Compiler
+    class Rule
+      attr_reader :root
+      attr_accessor :name
+
+      def initialize(root)
+        @root = root
+      end
+    end
+
+    # i % 1
+    class Expression
+      attr_reader :operand, :operation, :value
+
+      def initialize(operand, operation, value)
+        @operand = operand
+        @operation = operation
+        @value = value
+      end
+    end
+
+    # i % 1 = 0
+    class Relation
+      attr_reader :expression, :operation, :value
+
+      def initialize(expression, operation, value)
+        @expression = expression
+        @operation = operation
+        @value = value
+      end
+
+      def operand
+        expression.operand
+      end
+    end
+
+    # and/or
+    class Condition
+      attr_reader :right, :left
+
+      def initialize(right, left)
+        @right = right
+        @left = left
+      end
+    end
+
+    class AndCondition < Condition; end
+    class OrCondition < Condition; end
+
+    class Range
+      attr_reader :start, :finish
+
+      def initialize(start, finish)
+        @start = start
+        @finish = finish
+      end
+    end
+
+    class ValueSet
+      attr_reader :values
+
+      def initialize(values)
+        @values = values
+      end
+    end
+
+    class Operator
+      attr_reader :symbol
+
+      def initialize(symbol)
+        @symbol = symbol
+      end
+    end
+
+    class Operand
+      attr_reader :symbol
+
+      def initialize(symbol)
+        @symbol = symbol
+      end
+    end
+  end
+end