cldr-plurals 1.0.0

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

@@ -0,0 +1,153 @@
+# encoding: UTF-8
+
+require 'cldr-plurals/compiler/nodes'
+
+module CldrPlurals
+  module Compiler
+    class Parser
+
+      OPERATORS = [
+        :modulo, :equals, :not_equals
+      ]
+
+      SAMPLES = [
+        :int_sample, :dec_sample
+      ]
+
+      class UnexpectedTokenError < StandardError; end
+
+      attr_reader :token_list, :stack, :counter
+
+      def initialize(token_list)
+        @token_list = token_list
+        @stack = []
+        @counter = 0
+      end
+
+      def parse
+        until eol? || SAMPLES.include?(current_token.type) do
+          condition
+        end
+
+        Rule.new(stack.pop)
+      end
+
+      private
+
+      # and/or
+      def condition
+        and_condition
+
+        while consume(:or)
+          and_condition
+          stack.push(
+            OrCondition.new(stack.pop, stack.pop)
+          )
+        end
+      end
+
+      def and_condition
+        relation
+
+        while consume(:and)
+          relation
+          stack.push(
+            AndCondition.new(stack.pop, stack.pop)
+          )
+        end
+      end
+
+      def relation
+        expr = expression
+
+        stack.push(
+          if OPERATORS.include?(current_token.type)
+            Relation.new(expr, operator, value_set)
+          else
+            expr
+          end
+        )
+      end
+
+      def expression
+        Expression.new(operand, operator, value_set)
+      end
+
+      def operand
+        token = current_token
+        consume!(:operand)
+        Operand.new(token.value)
+      end
+
+      def operator
+        token = current_token
+        consume!(*OPERATORS)
+        Operator.new(token.value)
+      end
+
+      def value_set
+        values = [value]
+
+        while current_token.type == :comma
+          consume!(:comma)
+          values << value
+        end
+
+        if values.size == 1
+          values.first
+        else
+          ValueSet.new(values)
+        end
+      end
+
+      def value
+        first_token = current_token
+        consume!(:number)
+
+        case current_token.type
+          when :range
+            consume!(:range)
+            second_token = current_token
+            consume!(:number)
+            Range.new(first_token.value, second_token.value)
+          else
+            first_token.value
+        end
+      end
+
+      def next_token
+        @counter += 1
+        current_token
+      end
+
+      def current_token
+        if eol?
+          @eol_token ||= Token.new(nil, :eol)
+        else
+          token_list[counter]
+        end
+      end
+
+      def consume!(*token_types)
+        unless consume(*token_types)
+          raise UnexpectedTokenError,
+            "expected '#{token_types.join(', ')}', got '#{current_token.type}'"
+        end
+      end
+
+      def consume(*token_types)
+        if token_types.include?(current_token.type)
+          next_token
+          true
+        else
+          false
+        end
+      end
+
+      def eol?
+        counter >= token_list.size
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+
+module CldrPlurals
+  module Compiler
+    class Token
+      attr_reader :value, :type
+
+      def initialize(value, type)
+        @value = value
+        @type = type
+      end
+    end
+
+    class Tokenizer
+
+      TOKENS = {
+        /@integer/ => :int_sample,
+        /@decimal/ => :dec_sample,
+        /\u2026/   => :infinite_set,
+        /~/        => :sample_range,
+        /and/      => :and,
+        /or/       => :or,
+        /[niftvw]/ => :operand,
+        /,/        => :comma,
+        /\.\./     => :range,
+        /%/        => :modulo,
+        /=/        => :equals,
+        /\!=/      => :not_equals,
+        /[\d]+/    => :number
+      }
+
+      ALL_TOKENS = Regexp.compile(
+        TOKENS.map { |r, _| r.source }.join('|')
+      )
+
+      def self.tokenize(text)
+        text.scan(ALL_TOKENS).each_with_object([]) do |token, ret|
+          found_type = TOKENS.each_pair do |regex, token_type|
+            break token_type if token =~ regex
+          end
+
+          if found_type.is_a?(Symbol)
+            ret << make_token(token, found_type)
+          end
+        end
+      end
+
+      private
+
+      def self.make_token(value, type)
+        Token.new(value, type)
+      end
+
+    end
+  end
+end

data/lib/cldr-plurals/javascript_emitter.rb

@@ -0,0 +1,106 @@
+# encoding: UTF-8
+
+module CldrPlurals
+  class JavascriptEmitter < Compiler::Emitter
+    class << self
+
+      RUNTIME_VARS = %w(n i v w f t)
+
+      def emit_rules(rule_list)
+        parts = rule_list.rules.map do |rule|
+          "(#{emit_rule(rule)} ? '#{rule.name}' : "
+        end + ["'other'"]
+
+        chooser = "#{parts.join('')}#{')' * (parts.size - 1)}"
+        "(function(num, runtime) { #{build_runtime_vars}; return #{chooser}; })"
+      end
+
+      def emit_rule(rule)
+        emit(rule.root)
+      end
+
+      def emit_rule_standalone(rule)
+        "(function(n, i, f, t, v, w) { return #{emit_rule(rule)}; })"
+      end
+
+      protected
+
+      def build_runtime_vars
+        RUNTIME_VARS.map do |var|
+          "var #{var} = runtime.#{var}(num)"
+        end.join('; ')
+      end
+
+      def emit_or_condition(cond)
+        "(#{emit(cond.left)} || #{emit(cond.right)})"
+      end
+
+      def emit_and_condition(cond)
+        "(#{emit(cond.left)} && #{emit(cond.right)})"
+      end
+
+      def emit_expression(expr)
+        case expr.value
+          when CldrPlurals::Compiler::Range
+            neg = expr.operation.symbol == '!=' ? '!' : ''
+            operand_str = emit(expr.operand)
+            "#{neg}((#{operand_str} >= #{expr.value.start}) && (#{operand_str} <= #{expr.value.finish}))"
+          when CldrPlurals::Compiler::ValueSet
+            "(#{emit_value_set(expr.value, expr.operand, expr.operation)})"
+          else
+            emit_all(expr.operand, expr.operation, expr.value).join(' ')
+        end
+      end
+
+      def emit_relation(rel)
+        case rel.value
+          when CldrPlurals::Compiler::Range
+            expr = emit(rel.expression)
+            neg = rel.operation.symbol == '!=' ? '!' : ''
+            "#{neg}((#{expr} >= #{rel.value.start}) && (#{expr} <= #{rel.value.finish}))"
+          when CldrPlurals::Compiler::ValueSet
+            "(#{emit_value_set(rel.value, rel.expression, rel.operation)})"
+          else
+            emit_all(rel.expression, rel.operation, rel.value).join(' ')
+        end
+      end
+
+      def emit_value_set(value_set, operand, operator)
+        values = value_set.values.map do |value|
+          case value
+            when CldrPlurals::Compiler::Range
+              neg = operator.symbol == '!=' ? '!' : ''
+              operand_str = emit(operand)
+              "#{neg}((#{operand_str} >= #{value.start}) && (#{operand_str} <= #{value.finish}))"
+            else
+              "(#{emit(operand)} #{emit(operator)} #{emit(value)})"
+          end
+        end
+
+        if operator.symbol == '!='
+          values.join(' && ')
+        else
+          values.join(' || ')
+        end
+      end
+
+      def emit_operator(op)
+        case op.symbol
+          when '='
+            '=='
+          else
+            op.symbol
+        end
+      end
+
+      def emit_operand(op)
+        op.symbol
+      end
+
+      def emit_string(str)
+        str
+      end
+
+    end
+  end
+end

data/lib/cldr-plurals/ruby_emitter.rb

@@ -0,0 +1,108 @@
+# encoding: UTF-8
+
+module CldrPlurals
+  class RubyEmitter < Compiler::Emitter
+    class << self
+
+      RUNTIME_VARS = %w(n i v w f t)
+
+      def emit_rules(rule_list)
+        parts = rule_list.rules.map do |rule|
+          "(#{emit_rule(rule)} ? :#{rule.name} : "
+        end + [':other']
+
+        chooser = "#{parts.join('')}#{')' * (parts.size - 1)}"
+        "lambda { |num, runtime| #{build_runtime_vars}; #{chooser} }"
+      end
+
+      def emit_rule(rule)
+        emit(rule.root)
+      end
+
+      def emit_rule_standalone(rule)
+        "lambda { |n, i, f, t, v, w| #{emit_rule(rule)} }"
+      end
+
+      protected
+
+      def build_runtime_vars
+        RUNTIME_VARS.map do |var|
+          "#{var} = runtime.#{var}(num)"
+        end.join('; ')
+      end
+
+      def emit_or_condition(cond)
+        "(#{emit(cond.left)} || #{emit(cond.right)})"
+      end
+
+      def emit_and_condition(cond)
+        "(#{emit(cond.left)} && #{emit(cond.right)})"
+      end
+
+      def emit_expression(expr)
+        case expr.value
+          when CldrPlurals::Compiler::Range
+            neg = expr.operation.symbol == '!=' ? '!' : ''
+            "#{neg}(#{emit_range(expr.value)}).include?(#{emit(expr.operand)})"
+          when CldrPlurals::Compiler::ValueSet
+            "(#{emit_value_set(expr.value, expr.operand, expr.operation)})"
+          else
+            emit_all(expr.operand, expr.operation, expr.value).join(' ')
+        end
+      end
+
+      def emit_relation(rel)
+        case rel.value
+          when CldrPlurals::Compiler::Range
+            expr = emit(rel.expression)
+            neg = rel.operation.symbol == '!=' ? '!' : ''
+            "#{neg}(#{emit_range(rel.value)}).include?(#{expr})"
+          when CldrPlurals::Compiler::ValueSet
+            "(#{emit_value_set(rel.value, rel.expression, rel.operation)})"
+          else
+            emit_all(rel.expression, rel.operation, rel.value).join(' ')
+        end
+      end
+
+      def emit_value_set(value_set, operand, operator)
+        values = value_set.values.map do |value|
+          case value
+            when CldrPlurals::Compiler::Range
+              neg = operator.symbol == '!=' ? '!' : ''
+              "#{neg}(#{emit_range(value)}).include?(#{emit(operand)})"
+            else
+              "(#{emit(operand)} #{emit(operator)} #{emit(value)})"
+          end
+        end
+
+        if operator.symbol == '!='
+          values.join(' && ')
+        else
+          values.join(' || ')
+        end
+      end
+
+      def emit_range(range)
+        "#{emit(range.start)}..#{emit(range.finish)}"
+      end
+
+      def emit_operator(op)
+        case op.symbol
+          when '='
+            '=='
+          else
+            op.symbol
+        end
+      end
+
+      def emit_operand(op)
+        op.symbol
+      end
+
+      def emit_string(str)
+        str
+      end
+
+    end
+  end
+end

data/lib/cldr-plurals/version.rb

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

data/spec/javascript_sample_spec.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+
+require 'v8'
+require 'yaml'
+require 'spec_helper'
+require 'cldr-plurals/javascript_runtime'
+
+include CldrPlurals
+include CldrPlurals::Compiler
+
+describe 'ruby rules' do
+  each_rule do |locales, rule, samples|
+    context = V8::Context.new
+    js_code = JavascriptEmitter.emit_rule_standalone(rule)
+    rule_obj = context.eval(js_code)
+    runtime = context.eval(JavascriptRuntime.source)
+
+    samples.each do |sample_info|
+      context "#{sample_info[:type]} samples" do
+        sample_info[:samples].each do |sample|
+          it sample do
+            args = runtime.buildArgsFor(sample)
+            expect(rule_obj.call(*args)).to eq(true)
+          end
+        end
+      end
+    end
+  end
+end
+
+describe 'ruby rule lists' do
+  each_rule_list do |rule_list, samples_per_name|
+    context rule_list.locale do
+      context = V8::Context.new
+      js_code = rule_list.to_code(:javascript)
+      rule_proc = context.eval(js_code)
+      runtime = context.eval(JavascriptRuntime.source)
+
+      samples_per_name.each_pair do |name, samples|
+        samples.each do |sample|
+          it "#{name} #{sample}" do
+            expect(rule_proc.call(sample, runtime)).to eq(name.to_s)
+          end
+        end
+      end
+    end
+  end
+end