cldr-plurals-runtime-rb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5ab0a42da25484b9efc070180d80a9258e7111be
+  data.tar.gz: 22d5e9ba4ba43a0e186749a1e0a200f206274953
+SHA512:
+  metadata.gz: 243131d703e4e5624e20550806e33574de9ed5b9cc6d9a5911fed616bf2ce195e2bc2553acb375626e2c4335ed59d010bce0b63054cada1c13a3c8ebb33905e8
+  data.tar.gz: d8af452b349c416c37e7aafa27a3e451baec914ce9e5db03495330a0570d931a80f66a5b0ef313711e6f5d3276ea7ea23387227c097dc7f1d2d06d321ec4cecc

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,67 @@
+cldr-plurals-runtime-rb
+=================
+
+[![Build Status](https://travis-ci.org/camertron/cldr-plurals-runtime-rb.svg?branch=master)](http://travis-ci.org/camertron/cldr-plurals-runtime-rb)
+
+Ruby runtime methods for CLDR plural rules (see camertron/cldr-plurals).
+
+## Installation
+
+`gem install cldr-plurals-runtime-rb`
+
+## Usage
+
+```ruby
+require 'cldr-plurals/ruby_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-rb is an implementation of these calculations in Ruby. You can use them via the `CldrPlurals::RubyRuntime` module. Note that all methods take a stringified number as input:
+
+```ruby
+num = '1.04'
+CldrPlurals::RubyRuntime.n(num)  # => 1.04
+CldrPlurals::RubyRuntime.i(num)  # => 1
+```
+
+This runtime was created primarily for the [cldr-plurals](https://github.com/camertron/cldr-plurals) project, which can parse and emit Ruby code for a set of plural rules. Here's an example:
+
+```ruby
+require 'cldr-plurals'
+require 'cldr-plurals/ruby_runtime'
+
+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
+
+ruby_code = rules.to_code(:ruby)
+rule_proc = eval(ruby_code)
+
+rule_proc.call('3', CldrPlurals::RubyRuntime)  # => :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/ruby_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-rb.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'cldr-plurals/ruby-runtime/version'
+
+Gem::Specification.new do |s|
+  s.name     = "cldr-plurals-runtime-rb"
+  s.version  = ::CldrPlurals::RUBY_RUNTIME_VERSION
+  s.authors  = ["Cameron Dutro"]
+  s.email    = ["camertron@gmail.com"]
+  s.homepage = "http://github.com/camertron"
+
+  s.description = s.summary = 'Ruby runtime methods for CLDR plural rules (see camertron/cldr-plurals).'
+
+  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-runtime-rb.gemspec"]
+end

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

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

data/lib/cldr-plurals/ruby_runtime.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+
+module CldrPlurals
+  module RubyRuntime
+    class << self
+
+      def build_args_for(num_str)
+        [
+          n(num_str), i(num_str), f(num_str),
+          t(num_str), v(num_str), w(num_str)
+        ]
+      end
+
+      def n(str)
+        to_num(
+          if str.include?('.')
+            _n(str).gsub(/([0]+\z)/, '').chomp('.')
+          else
+            _n(str)
+          end
+        )
+      end
+
+      def i(str)
+        to_num(_i(str))
+      end
+
+      def f(str)
+        to_num(_f(str))
+      end
+
+      def t(str)
+        to_num(_t(str))
+      end
+
+      def v(str)
+        to_num(_v(str))
+      end
+
+      def w(str)
+        to_num(_w(str))
+      end
+
+      private
+
+      def to_num(str)
+        str.include?('.') ? str.to_f : str.to_i
+      end
+
+      # absolute value of the source number (integer and decimals).
+      def _n(str)
+        str.gsub(/(-)(.*)/, '\2')
+      end
+
+      # integer digits of n.
+      def _i(str)
+        _n(str).gsub(/([\d]+)(\..*)/, '\1')
+      end
+
+      # visible fractional digits in n, with trailing zeros.
+      def _f(str)
+        _n(str).gsub(/([\d]+\.?)(.*)/, '\2')
+      end
+
+      # visible fractional digits in n, without trailing zeros.
+      def _t(str)
+        _f(str).gsub(/([0]+\z)/, '')
+      end
+
+      # number of visible fraction digits in n, with trailing zeros.
+      def _v(str)
+        _f(str).length.to_s
+      end
+
+      # number of visible fraction digits in n, without trailing zeros.
+      def _w(str)
+        _t(str).length.to_s
+      end
+
+    end
+  end
+end

data/spec/ruby_runtime_spec.rb

@@ -0,0 +1,204 @@
+# encoding: UTF-8
+
+require 'yaml'
+require 'spec_helper'
+
+describe CldrPlurals::RubyRuntime do
+  let(:rt) { CldrPlurals::RubyRuntime }
+
+  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/ruby_runtime'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: cldr-plurals-runtime-rb
+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: []
+description: Ruby runtime methods for CLDR plural rules (see camertron/cldr-plurals).
+email:
+- camertron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cldr-plurals/ruby-runtime/version.rb
+- lib/cldr-plurals/ruby_runtime.rb
+- spec/ruby_runtime_spec.rb
+- spec/spec_helper.rb
+- Gemfile
+- History.txt
+- README.md
+- Rakefile
+- cldr-plurals-runtime-rb.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: Ruby runtime methods for CLDR plural rules (see camertron/cldr-plurals).
+test_files: []