cldr-plurals-runtime-js 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ca051f23ae6f1bc2bfcf02127fea20ffea73ef84
+  data.tar.gz: ab1c76440979b47534037e61e1cea2418af7bdad
+SHA512:
+  metadata.gz: 1f1d20a5e984352849a3fff3788e70bc225df96caf31563cfb3bb365c36ad803e3024ca8bc75c496109239219fd8d5adc4414efc4a7036564903fd94a965e111
+  data.tar.gz: 2bd8143495a80457757dc4a8e420d1bb9780e8aa02728cfe1519cd9b2a22fcc531e51872582378f35df2d6ac76af1cfa31fe50b32a055fcacfe7aac174cdb288

data/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem 'pry-nav'
+  gem 'rake'
+end
+
+group :test do
+  gem 'rspec'
+  gem 'rr'
+end

data/History.txt

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

data/README.md

@@ -0,0 +1,71 @@
+cldr-plurals-runtime-js
+=================
+
+[![Build Status](https://travis-ci.org/camertron/cldr-plurals-runtime-js.svg?branch=master)](http://travis-ci.org/camertron/cldr-plurals-runtime-js)
+
+Ruby runtime methods for CLDR plural rules (see camertron/cldr-plurals).
+
+## Installation
+
+`gem install cldr-plurals-runtime-js`
+
+## Usage
+
+```ruby
+require 'cldr-plurals/javascript_runtime'
+```
+
+## Functionality
+
+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. The document describes how to determine the various parts of a number and how to use those parts to determine the plural rule. The parts as they appear in TR35 are:
+
+| Symbol | Value                                                          |
+|:-------|----------------------------------------------------------------|
+| n      | absolute value of the source number (integer and decimals).    |
+| i      | integer digits of n.                                           |
+| v      | number of visible fraction digits in n, with trailing zeros.   |
+| w      | number of visible fraction digits in n, without trailing zeros.|
+| f      | visible fractional digits in n, with trailing zeros.           |
+| t      | visible fractional digits in n, without trailing zeros.        |
+
+cldr-plurals-runtime-js is an implementation of these calculations in Javascript, packaged as a rubygem. You can get the source code for the runtime by querying the `CldrPlurals::JavascriptRuntime` module:
+
+```ruby
+CldrPlurals::JavascriptRuntime.source
+```
+
+The source code simply contains a single Javascript object. It isn't packaged as a CommonJs module or anything fancy like that - it's just a straight js object. This makes it easier to test in Ruby. Also, since all the users of this runtime currently just copy the source into larger projects, there's no need for a package. Let me know if you want one <3
+
+When evaluated inside a Javascript environment like V8 (via [therubyracer](https://github.com/cowboyd/therubyracer)), the runtime can be passed to [cldr-plurals](https://github.com/camertron/cldr-plurals) to determine the plural form for a number:
+
+```ruby
+require 'v8'
+require 'cldr-plurals'
+require 'cldr-plurals/javascript_runtime'
+
+context = V8::Context.new
+runtime = context.eval(CldrPlurals::JavascriptRuntime.source)
+
+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
+
+js_code = rules.to_code(:javascript)
+js_obj = context.eval(js_code)
+
+js_obj.call('3', runtime)  # => '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,18 @@
+# encoding: UTF-8
+
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require './lib/cldr-plurals/javascript_runtime'
+
+Bundler::GemHelper.install_tasks
+
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/cldr-plurals-runtime-js.gemspec

@@ -0,0 +1,20 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'cldr-plurals/javascript-runtime/version'
+
+Gem::Specification.new do |s|
+  s.name     = "cldr-plurals-runtime-js"
+  s.version  = ::CldrPlurals::JAVASCRIPT_RUNTIME_VERSION
+  s.authors  = ["Cameron Dutro"]
+  s.email    = ["camertron@gmail.com"]
+  s.homepage = "http://github.com/camertron"
+
+  s.description = s.summary = 'Javascript runtime methods for CLDR plural rules (see camertron/cldr-plurals).'
+
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+
+  s.add_development_dependency 'therubyracer', '0.12.0'
+
+  s.require_path = 'lib'
+  s.files = Dir["{lib,spec}/**/*", "Gemfile", "History.txt", "README.md", "Rakefile", "cldr-plurals-runtime-js.gemspec"]
+end

data/lib/cldr-plurals/javascript-runtime/version.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+module CldrPlurals
+  JAVASCRIPT_RUNTIME_VERSION = '1.0.0'
+end

data/lib/cldr-plurals/javascript_runtime.js

@@ -0,0 +1,78 @@
+(function() {
+  this.buildArgsFor = function(num_str) {
+    return [
+      this.n(num_str), this.i(num_str), this.f(num_str),
+      this.t(num_str), this.v(num_str), this.w(num_str)
+    ];
+  }
+
+  this.n = function(str) {
+    if (str.indexOf('.') > -1) {
+      return this.toNum(this._n(str).replace(/([0]+\.$)/, ''));
+    } else {
+      return this.toNum(this._n(str));
+    }
+  }
+
+  this.i = function(str) {
+    return this.toNum(this._i(str));
+  }
+
+  this.f = function(str) {
+    return this.toNum(this._f(str));
+  }
+
+  this.t = function(str) {
+    return this.toNum(this._t(str));
+  }
+
+  this.v = function(str) {
+    return this.toNum(this._v(str));
+  }
+
+  this.w = function(str) {
+    return this.toNum(this._w(str));
+  }
+
+  // private
+
+  this.toNum = function(str) {
+    if (str.length == 0) {
+      return 0;
+    } else {
+      return str.indexOf('.') > -1 ? parseFloat(str) : parseInt(str);
+    }
+  }
+
+  // absolute value of the source number (integer and decimals).
+  this._n = function(str) {
+    return /(-)?(.*)/.exec(str)[2];
+  }
+
+  /// integer digits of n.
+  this._i = function(str) {
+    return /([\d]+)(\..*)?/.exec(this._n(str))[1];
+  }
+
+  // visible fractional digits in n, with trailing zeros.
+  this._f = function(str) {
+    return /([\d]+\.?)(.*)/.exec(this._n(str))[2];
+  }
+
+  // visible fractional digits in n, without trailing zeros.
+  this._t = function(str) {
+    return this._f(str).replace(/([0]+$)/, '');
+  }
+
+  // number of visible fraction digits in n, with trailing zeros.
+  this._v = function(str) {
+    return this._f(str).length.toString();
+  }
+
+  // number of visible fraction digits in n, without trailing zeros.
+  this._w = function(str) {
+    return this._t(str).length.toString();
+  }
+
+  return this;
+})();

data/lib/cldr-plurals/javascript_runtime.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+module CldrPlurals
+  module JavascriptRuntime
+    class << self
+
+      def source
+        @source ||= File.read(source_file)
+      end
+
+      private
+
+      def source_file
+        @source_file ||= File.expand_path(
+          './javascript_runtime.js', File.dirname(__FILE__)
+        )
+      end
+
+    end
+  end
+end

data/spec/javascript_runtime_spec.rb

@@ -0,0 +1,207 @@
+# encoding: UTF-8
+
+require 'v8'
+require 'spec_helper'
+
+describe CldrPlurals::JavascriptRuntime do
+  let(:context) { V8::Context.new }
+  let(:rt) do
+    context.eval(CldrPlurals::JavascriptRuntime.source)
+  end
+
+  context 'with an integer' do
+    let(:num) { '1' }
+
+    it '#n returns n without trailing zeroes' do
+      expect(rt.n(num)).to eq(1)
+    end
+
+    it '#i returns the int value' do
+      expect(rt.i(num)).to eq(1)
+    end
+
+    it '#v returns num of visible fraction digits (with zeroes)' do
+      expect(rt.v(num)).to eq(0)
+    end
+
+    it '#w returns num of visible fraction digits (without zeroes)' do
+      expect(rt.w(num)).to eq(0)
+    end
+
+    it '#f returns visible fractional digits (with zeroes)' do
+      expect(rt.f(num)).to eq(0)
+    end
+
+    it '#t returns visible fractional digits (without zeroes)' do
+      expect(rt.t(num)).to eq(0)
+    end
+  end
+
+  context 'with a zero decimal' do
+    let(:num) { '1.0' }
+
+    it '#n returns n without trailing zeroes' do
+      expect(rt.n(num)).to eq(1)
+    end
+
+    it '#i returns the int value' do
+      expect(rt.i(num)).to eq(1)
+    end
+
+    it '#v returns num of visible fraction digits (with zeroes)' do
+      expect(rt.v(num)).to eq(1)
+    end
+
+    it '#w returns num of visible fraction digits (without zeroes)' do
+      expect(rt.w(num)).to eq(0)
+    end
+
+    it '#f returns visible fractional digits (with zeroes)' do
+      expect(rt.f(num)).to eq(0)
+    end
+
+    it '#t returns visible fractional digits (without zeroes)' do
+      expect(rt.t(num)).to eq(0)
+    end
+  end
+
+  context 'with a double-precision zero decimal' do
+    let(:num) { '1.00' }
+
+    it '#n returns n without trailing zeroes' do
+      expect(rt.n(num)).to eq(1)
+    end
+
+    it '#i returns the int value' do
+      expect(rt.i(num)).to eq(1)
+    end
+
+    it '#v returns num of visible fraction digits (with zeroes)' do
+      expect(rt.v(num)).to eq(2)
+    end
+
+    it '#w returns num of visible fraction digits (without zeroes)' do
+      expect(rt.w(num)).to eq(0)
+    end
+
+    it '#f returns visible fractional digits (with zeroes)' do
+      expect(rt.f(num)).to eq(0)
+    end
+
+    it '#t returns visible fractional digits (without zeroes)' do
+      expect(rt.t(num)).to eq(0)
+    end
+  end
+
+  context 'with a non-zero decimal' do
+    let(:num) { '1.3' }
+
+    it '#n returns n without trailing zeroes' do
+      expect(rt.n(num)).to eq(1.3)
+    end
+
+    it '#i returns the int value' do
+      expect(rt.i(num)).to eq(1)
+    end
+
+    it '#v returns num of visible fraction digits (with zeroes)' do
+      expect(rt.v(num)).to eq(1)
+    end
+
+    it '#w returns num of visible fraction digits (without zeroes)' do
+      expect(rt.w(num)).to eq(1)
+    end
+
+    it '#f returns visible fractional digits (with zeroes)' do
+      expect(rt.f(num)).to eq(3)
+    end
+
+    it '#t returns visible fractional digits (without zeroes)' do
+      expect(rt.t(num)).to eq(3)
+    end
+  end
+
+  context 'with a double-precision trailing zero decimal' do
+    let(:num) { '1.30' }
+
+    it '#n returns n without trailing zeroes' do
+      expect(rt.n(num)).to eq(1.3)
+    end
+
+    it '#i returns the int value' do
+      expect(rt.i(num)).to eq(1)
+    end
+
+    it '#v returns num of visible fraction digits (with zeroes)' do
+      expect(rt.v(num)).to eq(2)
+    end
+
+    it '#w returns num of visible fraction digits (without zeroes)' do
+      expect(rt.w(num)).to eq(1)
+    end
+
+    it '#f returns visible fractional digits (with zeroes)' do
+      expect(rt.f(num)).to eq(30)
+    end
+
+    it '#t returns visible fractional digits (without zeroes)' do
+      expect(rt.t(num)).to eq(3)
+    end
+  end
+
+  context 'with a double-precision leading zero decimal' do
+    let(:num) { '1.03' }
+
+    it '#n returns n without trailing zeroes' do
+      expect(rt.n(num)).to eq(1.03)
+    end
+
+    it '#i returns the int value' do
+      expect(rt.i(num)).to eq(1)
+    end
+
+    it '#v returns num of visible fraction digits (with zeroes)' do
+      expect(rt.v(num)).to eq(2)
+    end
+
+    it '#w returns num of visible fraction digits (without zeroes)' do
+      expect(rt.w(num)).to eq(2)
+    end
+
+    it '#f returns visible fractional digits (with zeroes)' do
+      expect(rt.f(num)).to eq(3)
+    end
+
+    it '#t returns visible fractional digits (without zeroes)' do
+      expect(rt.t(num)).to eq(3)
+    end
+  end
+
+  context 'with a triple-precision decimal' do
+    let(:num) { '1.230' }
+
+    it '#n returns n without trailing zeroes' do
+      expect(rt.n(num)).to eq(1.23)
+    end
+
+    it '#i returns the int value' do
+      expect(rt.i(num)).to eq(1)
+    end
+
+    it '#v returns num of visible fraction digits (with zeroes)' do
+      expect(rt.v(num)).to eq(3)
+    end
+
+    it '#w returns num of visible fraction digits (without zeroes)' do
+      expect(rt.w(num)).to eq(2)
+    end
+
+    it '#f returns visible fractional digits (with zeroes)' do
+      expect(rt.f(num)).to eq(230)
+    end
+
+    it '#t returns visible fractional digits (without zeroes)' do
+      expect(rt.t(num)).to eq(23)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+require 'rspec'
+require 'pry-nav'
+require 'cldr-plurals/javascript_runtime'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: cldr-plurals-runtime-js
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cameron Dutro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: therubyracer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+description: Javascript runtime methods for CLDR plural rules (see camertron/cldr-plurals).
+email:
+- camertron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cldr-plurals/javascript-runtime/version.rb
+- lib/cldr-plurals/javascript_runtime.js
+- lib/cldr-plurals/javascript_runtime.rb
+- spec/javascript_runtime_spec.rb
+- spec/spec_helper.rb
+- Gemfile
+- History.txt
+- README.md
+- Rakefile
+- cldr-plurals-runtime-js.gemspec
+homepage: http://github.com/camertron
+licenses: []
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Javascript runtime methods for CLDR plural rules (see camertron/cldr-plurals).
+test_files: []