twitter_cldr_js 2.3.2 → 2.4.0

data/lib/twitter_cldr/js/renderers/plurals/rules/plural_rules_compiler.rb

@@ -1,93 +0,0 @@
-# encoding: UTF-8
-
-# Copyright 2012 Twitter, Inc
-# http://www.apache.org/licenses/LICENSE-2.0
-
-require 'ruby_parser'
-
-module TwitterCldr
-  module Js
-    module Renderers
-      module PluralRules
-
-        class PluralRulesCompiler
-
-          class << self
-            def rule_to_js(rule_code)
-              tree = RubyParser.new.parse(rule_code).to_a
-              "function(n) { return #{statement_list(tree)} }"
-            end
-
-            protected
-
-            def statement_list(tree)
-              if tree.first == :block
-                tree[1..-1].map { |sub_tree| send(:"_#{sub_tree.first}", sub_tree) }.join(" ")
-              else
-                send(:"_#{tree.first}", tree)
-              end
-            end
-
-            def _if(tree)
-              result = "(function() { if (#{statement_list(tree[1])}) { return #{statement_list(tree[2])} }"
-              result << " else { return #{statement_list(tree[3])} }" if tree[3]
-              "#{result} })();"
-            end
-
-            def _lvar(tree)
-              tree.first.to_s
-            end
-
-            def _call(tree)
-              case tree[2]
-                when :==, :%, :<, :>  # special operators that actually resolve to method calls
-                  "#{statement_list(tree[1])} #{tree[2]} #{statement_list(tree[3])}"
-                when :include?
-                  "#{statement_list(tree[1])}.indexOf(#{statement_list(tree[3])}) >= 0"
-                when :between?
-                  smt = "((#{statement_list(tree[1])} >= #{statement_list(tree[3][1])})"
-                  smt << " && (#{statement_list(tree[1])} <= #{statement_list(tree[3][2])}))"
-                  smt
-                else
-                  # this should be the only case where tree[1] might be nil (i.e. the method was not called on any object)
-                  call = tree[1] ? "#{statement_list(tree[1])}.#{tree[2]}" : tree[2].to_s
-                  arglist = statement_list(tree[3])
-                  arglist == "" ? call : "#{call}(#{arglist})"
-              end
-            end
-
-            def _arglist(tree)
-              tree[1..-1].map { |arg| statement_list(arg) }.join(", ")
-            end
-
-            def _lit(tree)
-              if tree[1].is_a?(Symbol) || tree[1].is_a?(String)
-                %Q("#{tree[1]}")
-              else
-                tree[1]
-              end
-            end
-
-            def _array(tree)
-              "[#{tree[1..-1].map { |arg| statement_list(arg) }.join(", ")}]"
-            end
-
-            def _not(tree)
-              "!(#{statement_list(tree[1])})"
-            end
-
-            def _and(tree)
-              "#{statement_list(tree[1])} && #{statement_list(tree[2])}"
-            end
-
-            def _or(tree)
-              "#{statement_list(tree[1])} || #{statement_list(tree[2])}"
-            end
-          end
-
-        end
-
-      end
-    end
-  end
-end

data/spec/ruby/renderers/plurals/plural_rules_compiler_spec.rb

@@ -1,56 +0,0 @@
-# encoding: UTF-8
-
-# Copyright 2012 Twitter, Inc
-# http://www.apache.org/licenses/LICENSE-2.0
-
-require File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec_helper")
-
-include TwitterCldr::Js::Renderers::PluralRules
-
-describe PluralRulesCompiler do
-  describe "#rule_to_js" do
-    it "handles a single plural rule" do
-      PluralRulesCompiler.rule_to_js(":other").should == 'function(n) { return "other" }'
-    end
-
-    it "handles a conditional plural rule (eg. English)" do
-      PluralRulesCompiler.rule_to_js("n == 1 ? :one : :other").should == 'function(n) { return (function() { if (n == 1) { return "one" } else { return "other" } })(); }'
-    end
-
-    it "handles an include? call" do
-      PluralRulesCompiler.rule_to_js("[2, 3, 4].include?(n)").should == "function(n) { return [2, 3, 4].indexOf(n) >= 0 }"
-    end
-
-    it "handles a between? call" do
-      PluralRulesCompiler.rule_to_js("n.between?(0, 2)").should == "function(n) { return ((n >= 0) && (n <= 2)) }"
-    end
-
-    it "handles the modulus operator" do
-      PluralRulesCompiler.rule_to_js("n % 10").should == "function(n) { return n % 10 }"
-    end
-
-    it "handles < and > operators" do
-      PluralRulesCompiler.rule_to_js("n > 10").should == "function(n) { return n > 10 }"
-      PluralRulesCompiler.rule_to_js("n < 10").should == "function(n) { return n < 10 }"
-    end
-
-    it "handles 'and', 'or', and 'not' operators" do
-      PluralRulesCompiler.rule_to_js("n and n").should == "function(n) { return n && n }"
-      PluralRulesCompiler.rule_to_js("n or n").should == "function(n) { return n || n }"
-      PluralRulesCompiler.rule_to_js("not n").should == "function(n) { return !(n) }"
-    end
-
-    it "compounds include? and the modulus operator" do
-      PluralRulesCompiler.rule_to_js("[2, 3, 4].include?(n % 10)").should == "function(n) { return [2, 3, 4].indexOf(n % 10) >= 0 }"
-    end
-
-    it "compounds include?, modulus, and an if statement" do
-      PluralRulesCompiler.rule_to_js("[2, 3, 4].include?(n % 10) ? :one : :other").should == 'function(n) { return (function() { if ([2, 3, 4].indexOf(n % 10) >= 0) { return "one" } else { return "other" } })(); }'
-    end
-
-    it "chains two if statements (eg. Polish)" do
-      ruby_string = "n == 1 ? :one : [2, 3, 4].include?(n % 10) && ![12, 13, 14].include?(n % 100) && ![22, 23, 24].include?(n % 100) ? :few : :other"
-      PluralRulesCompiler.rule_to_js(ruby_string).should == 'function(n) { return (function() { if (n == 1) { return "one" } else { return (function() { if ([2, 3, 4].indexOf(n % 10) >= 0 && !([12, 13, 14].indexOf(n % 100) >= 0) && !([22, 23, 24].indexOf(n % 100) >= 0)) { return "few" } else { return "other" } })(); } })(); }'
-    end
-  end
-end

data/spec/ruby/spec_helper.rb

@@ -1,11 +0,0 @@
-# encoding: UTF-8
-
-# Copyright 2012 Twitter, Inc
-# http://www.apache.org/licenses/LICENSE-2.0
-
-require 'rspec'
-require 'twitter_cldr/js'
-
-RSpec.configure do |config|
-  config.mock_with :rr
-end