slang 0.34.0

data/lib/slang/version.rb

@@ -0,0 +1,3 @@
+module Slang
+  VERSION = "0.34.0"
+end

data/slang.gemspec

@@ -0,0 +1,20 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "slang/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "slang"
+  gem.version       = Slang::VERSION
+  gem.authors       = ["Adrian B. Danieli"]
+  gem.email         = ["support@getslang.com"]
+  gem.summary       = "Slang Ruby Client"
+  gem.homepage      = "https://getslang.com/"
+
+  gem.files         = `git ls-files`.split
+  gem.test_files    = gem.files.grep(%r{\Atest/})
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = ">= 2.0.0"
+
+  gem.add_runtime_dependency "oj", "~> 2.12"
+end

data/test/data/snapshot.json

@@ -0,0 +1,64 @@
+[
+  6,
+  "6DIMm9XmJ5GkYOBpV9Hg",
+  1403213582,
+  "en",
+  [
+    ["de","en","one_other",true,"german","deutsch"],
+    ["en",null,"one_other",true]
+  ],
+  [
+    ["apples_bananas","apples=N:bananas=N",
+      [
+        "one:one","",
+        "one:other","",
+        "one:zero","",
+        "other:one","",
+        "other:other","",
+        "other:zero","",
+        "zero:one","",
+        "zero:other","",
+        "zero:zero",""
+      ],
+      [
+        "one:one","I'll eat one apple and one banana.",
+        "one:other","I'll eat one apple, and then I'll eat {bananas} bananas.",
+        "one:zero","I'll eat one apple, but no bananas.",
+        "other:one","I'll eat {apples} apples, but just one banana.",
+        "other:other","I'll eat {apples} apples and {bananas} bananas.",
+        "other:zero","I'll eat {apples} apples, but no bananas.",
+        "zero:one","I don't like apples, but I'll eat a banana.",
+        "zero:other","I don't like apples, but I'll eat {bananas} bananas.",
+        "zero:zero","I don't like to eat apples nor bananas."
+      ]
+    ],
+    ["foo","","voo","foo"],
+    ["hello","","Guten Tag {a} und {b}.","Hello {a} and {b}."],
+    ["missing","","","Found in English"],
+    ["profile_update","gender=G",
+      [
+        "female","",
+        "male","",
+        "unknown",""
+      ],
+      [
+        "female","{name} updated her profile.",
+        "male","{name} updated his profile.",
+        "unknown","{name} updated their profile."
+      ]
+    ],
+    ["unread","count=N",
+      [
+        "one","",
+        "other","",
+        "zero",""
+      ],
+      [
+        "one","You have one unread message.",
+        "other","You have {count} unread messages.",
+        "zero",""
+      ]
+    ],
+    ["welcome","","Willkommen {user}!","Welcome {user}!"]
+  ]
+]

data/test/helper.rb

@@ -0,0 +1,4 @@
+require "bundler/setup"
+require "minitest/autorun"
+module Slang; TEST=true; end
+require "slang"

data/test/test_locale.rb

@@ -0,0 +1,47 @@
+require "helper"
+
+module Slang
+  class TestLocale < Minitest::Test
+    Locale = Snapshot::Locale
+    parallelize_me!
+
+    def setup
+      @array = ["de", "en", "one_other", true, "german"]
+      @locale = Locale.new(@array, 2)
+    end
+
+    def test_code_symbolized
+      assert_equal(:de, @locale.code)
+    end
+
+    def test_fallback_symbolized
+      assert_equal(:en, @locale.fallback)
+    end
+
+    def test_aliases_symbolized
+      assert_equal([ :german ], @locale.aliases)
+    end
+
+    def test_pluralization_method
+      assert_equal(:pluralization_one_other, @locale.pluralization_method)
+    end
+
+    def test_translation_index
+      assert_equal(2, @locale.translation_index)
+    end
+
+    def test_missing_fallback
+      @array[1] = nil
+      locale = Locale.new(@array, 0)
+      assert_nil(locale.fallback)
+    end
+
+    def test_missing_aliases
+      @array = @array.slice(0,4)
+      locale = Locale.new(@array, 0)
+      assert_empty(locale.aliases)
+    end
+
+  end
+
+end

data/test/test_rules.rb

@@ -0,0 +1,133 @@
+require "helper"
+
+module Slang
+  class TestRules < Minitest::Test
+    Rules = Snapshot::Rules
+    Locale = Snapshot::Locale
+
+    parallelize_me!
+
+    def setup
+      @rules = Object.new.extend(Rules)
+    end
+
+    def test_rules_from_pattern
+      gender_rule = [ "gender", :gender ]
+      count_rule = [ "count", :pluralization ]
+      number_rule = [ "num", :pluralization ]
+
+      assert_equal([gender_rule], @rules.rules_from_pattern("gender=G"))
+      assert_equal([count_rule], @rules.rules_from_pattern("count=N"))
+      assert_equal([gender_rule, count_rule], @rules.rules_from_pattern("gender=G:count=N"))
+      assert_equal([count_rule, gender_rule, number_rule], @rules.rules_from_pattern("count=N:gender=G:num=N"))
+    end
+
+    def test_evaluate_rule
+      locale = Locale.new(["de","en","one_other",true,"german"], 0)
+
+      assert_equal(Rules::GENDER_FEMALE, @rules.evaluate_rule(locale, :gender, "Female"))
+      assert_equal(Rules::GENDER_MALE, @rules.evaluate_rule(locale, :gender, "M"))
+      assert_equal(Rules::GENDER_UNKNOWN, @rules.evaluate_rule(locale, :gender, nil))
+
+      assert_equal(Rules::PLURAL_ZERO_OR_OTHER, @rules.evaluate_rule(locale, :pluralization, 0))
+      assert_equal(Rules::PLURAL_ONE, @rules.evaluate_rule(locale, :pluralization, 1))
+      assert_equal(Rules::PLURAL_OTHER, @rules.evaluate_rule(locale, :pluralization, 2))
+    end
+
+    def test_gender
+      assert_equal(Rules::GENDER_FEMALE, @rules.gender(:female))
+      assert_equal(Rules::GENDER_MALE, @rules.gender(:male))
+      assert_equal(Rules::GENDER_UNKNOWN, @rules.gender(:unknown))
+      assert_equal(Rules::GENDER_UNKNOWN, @rules.gender(nil))
+    end
+
+    def test_genderize
+      assert_equal(:female, @rules.genderize(:female))
+      assert_equal(:female, @rules.genderize("female"))
+      assert_equal(:female, @rules.genderize("FEMALE"))
+      assert_equal(:female, @rules.genderize("f"))
+      assert_equal(:female, @rules.genderize("F"))
+      assert_equal(:female, @rules.genderize(:F))
+
+      assert_equal(:male, @rules.genderize(:male))
+      assert_equal(:male, @rules.genderize("male"))
+      assert_equal(:male, @rules.genderize("MALE"))
+      assert_equal(:male, @rules.genderize("m"))
+      assert_equal(:male, @rules.genderize("M"))
+      assert_equal(:male, @rules.genderize(:M))
+
+      assert_equal(:unknown, @rules.genderize(:unknown))
+      assert_equal(:unknown, @rules.genderize(nil))
+      assert_equal(:unknown, @rules.genderize("unknown"))
+      assert_equal(:unknown, @rules.genderize("UNKNOWN"))
+      assert_equal(:unknown, @rules.genderize(""))
+    end
+
+    def test_pluralization_other
+      assert_equal(Rules::PLURAL_ZERO_OR_OTHER, @rules.pluralization_other(0))
+      [1, 1.1, 2, 3, 4, 5, 10, 11, 12, 20, 21, 22, 98, 99, 100].each do |n|
+        assert_equal(Rules::PLURAL_OTHER, @rules.pluralization_other(n))
+      end
+    end
+
+    def test_pluralization_one_other
+      assert_equal(Rules::PLURAL_ZERO_OR_OTHER, @rules.pluralization_one_other(0))
+      assert_equal(Rules::PLURAL_ONE, @rules.pluralization_one_other(1))
+      [1.1, 2, 3, 4, 5, 10, 11, 12, 20, 21, 22, 98, 99, 100].each do |n|
+        assert_equal(Rules::PLURAL_OTHER, @rules.pluralization_one_other(n))
+      end
+    end
+
+    def test_pluralization_zero_and_one_other
+      assert_equal(Rules::PLURAL_ZERO_OR_ONE, @rules.pluralization_zero_and_one_other(0))
+      assert_equal(Rules::PLURAL_ONE, @rules.pluralization_zero_and_one_other(1))
+      [1.1, 2, 3, 4, 5, 10, 11, 12, 20, 21, 22, 98, 99, 100].each do |n|
+        assert_equal(Rules::PLURAL_OTHER, @rules.pluralization_zero_and_one_other(n))
+      end
+    end
+
+    def test_pluralization_east_slavic
+      assert_equal(Rules::PLURAL_ZERO_OR_MANY, @rules.pluralization_east_slavic(0))
+      [1, 21, 31, 41, 91, 101].each do |n|
+        assert_equal(Rules::PLURAL_ONE, @rules.pluralization_east_slavic(n))
+      end
+      [2, 3, 4, 22, 23, 24, 92, 93, 94, 102, 103, 104].each do |n|
+        assert_equal(Rules::PLURAL_FEW, @rules.pluralization_east_slavic(n))
+      end
+      [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 25, 29, 90, 95, 99, 100].each do |n|
+        assert_equal(Rules::PLURAL_MANY, @rules.pluralization_east_slavic(n))
+      end
+      assert_equal(Rules::PLURAL_OTHER, @rules.pluralization_east_slavic(1.1))
+    end
+
+    def test_pluralization_arabic
+      assert_equal(Rules::PLURAL_ZERO, @rules.pluralization_arabic(0))
+      assert_equal(Rules::PLURAL_ONE, @rules.pluralization_arabic(1))
+      assert_equal(Rules::PLURAL_TWO, @rules.pluralization_arabic(2))
+      [3, 4, 5, 6, 7, 8, 9, 10, 103, 104, 105, 106, 107, 108, 109, 110].each do |n|
+        assert_equal(Rules::PLURAL_FEW, @rules.pluralization_arabic(n))
+      end
+      [11, 12, 13, 21, 99, 111, 112, 199].each do |n|
+        assert_equal(Rules::PLURAL_MANY, @rules.pluralization_arabic(n))
+      end
+      [1.1, 100, 101, 102, 200, 201, 202].each do |n|
+        assert_equal(Rules::PLURAL_OTHER, @rules.pluralization_arabic(n))
+      end
+    end
+
+    def test_pluralization_polish
+      assert_equal(Rules::PLURAL_ZERO_OR_MANY, @rules.pluralization_polish(0))
+      assert_equal(Rules::PLURAL_ONE, @rules.pluralization_polish(1))
+      [2, 3, 4, 22, 23, 24, 92, 93, 94, 102, 103, 104].each do |n|
+        assert_equal(Rules::PLURAL_FEW, @rules.pluralization_polish(n))
+      end
+      [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 25, 26, 27, 28, 29, 30, 31, 100, 101].each do |n|
+        assert_equal(Rules::PLURAL_MANY, @rules.pluralization_polish(n))
+      end
+      [1.2, 2.07, 5.94].each do |n|
+        assert_equal(Rules::PLURAL_OTHER, @rules.pluralization_polish(n), n)
+      end
+    end
+
+  end
+end

data/test/test_snapshot.rb

@@ -0,0 +1,132 @@
+# TODO: test key generation
+require "helper"
+
+module Slang
+
+  class TestSnapshot < Minitest::Test
+
+    # TODO: when parallelized, the stubbed Slang.config method fails nondeterministically, but only when the entire
+    #       test suite is run. If just this file is run (TEST=test/test_snapshot.rb) it does not fail.
+    #       To replicate, uncomment parallelize_me!, and run: while :; do rake; done
+    #parallelize_me!
+
+    class KeyReporterStub
+      def unknown_key(key, variable_map)
+        # do nothing
+      end
+    end
+
+    SNAPSHOT_KEYS = %w(apples_bananas foo hello missing profile_update unread welcome)
+
+    def setup
+      @array = Oj.strict_load(File.read("test/data/snapshot.json"))
+      @snapshot = Snapshot.new(@array) # format, id, timestamp, default_locale_code, locales_array, translations_array
+    end
+
+    def test_initialize
+      assert_equal("6DIMm9XmJ5GkYOBpV9Hg", @snapshot.id)
+      assert_equal(1403213582, @snapshot.timestamp)
+      assert_equal(:en, @snapshot.default_locale.code)
+    end
+
+    def test_initialize_unknown_format
+      @array[0] = 0
+      @snapshot = Snapshot.new(@array)
+      assert_equal("6DIMm9XmJ5GkYOBpV9Hg", @snapshot.id)
+      assert_equal(1403213582, @snapshot.timestamp)
+      assert_equal(:en, @snapshot.default_locale.code)
+    end
+
+    def test_initialize_unknown_default_locale
+      @array[3] = "xx"
+      @snapshot = Snapshot.new(@array)
+      assert_equal(:de, @snapshot.default_locale.code)
+    end
+
+    def test_initialize_empty
+      s = Snapshot.from_json(Snapshot::EMPTY_SNAPSHOT_JSON)
+      assert_equal("0" * 20, s.id)
+      assert_equal(0, s.timestamp)
+      assert_equal(:en, s.default_locale.code)
+      assert_empty(s.keys)
+    end
+
+    def test_keys
+      assert_equal(SNAPSHOT_KEYS, @snapshot.keys)
+    end
+
+    def test_translate
+      assert_equal("foo", @snapshot.translate(:en, "foo", {}))
+      assert_equal("foo", @snapshot.translate(:en, :foo, {}))
+      assert_equal("foo", @snapshot.translate(:en, "FOo", {}))
+      assert_equal("voo", @snapshot.translate(:de, "foo", {}))
+    end
+
+    def test_translate_missing
+      assert_equal("{{en:missing_key}}", @snapshot.translate(:en, "missing_key", {}))
+      Slang.stub(:key_reporter, KeyReporterStub.new) do
+        assert_equal("MissingKey", @snapshot.translate(:en, "missing_key", {}))
+      end
+    end
+
+    def test_translate_missing_with_fallback
+      assert_equal("Found in English", @snapshot.translate(:de, "missing", {}))
+    end
+
+    def test_translate_interpolation
+      assert_equal("Welcome sickp!", @snapshot.translate(:en, "welcome", user: "sickp"))
+      assert_equal("Willkommen sickp!", @snapshot.translate(:de, "welcome", user: "sickp"))
+    end
+
+    def test_translate_missing_interpolation_variable
+      assert_equal("Hello {a} and {b}.", @snapshot.translate(:en, "hello", {}))
+      assert_equal("Hello {a} and Bob.", @snapshot.translate(:en, "hello", b: "Bob"))
+    end
+
+    def test_translate_rule
+      assert_equal("Jack updated his profile.", @snapshot.translate(:en, "profile_update", name: "Jack", gender: "M"))
+      assert_equal("Jill updated her profile.", @snapshot.translate(:en, "profile_update", name: "Jill", gender: "F"))
+      assert_equal("Thing 1 updated their profile.", @snapshot.translate(:en, "profile_update", name: "Thing 1", gender: nil))
+    end
+
+    def test_translate_missing_rule_variable
+      assert_equal("{{en:profile_update:<gender>}}", @snapshot.translate(:en, "profile_update", name: "Jack"))
+    end
+
+    def test_translate_with_locale_alias
+      assert_equal("Guten Tag Jack und Jill.", @snapshot.translate(:german, "hello", a: "Jack", b: "Jill"))
+    end
+
+    def test_translate_unknown_locale
+      assert_equal("Welcome earthling!", @snapshot.translate(:martian, "welcome", user: "earthling"))
+    end
+
+    def test_translate_key_name_malformed
+      assert_equal("{{en:bad$langkey}}", @snapshot.translate(:en, "bad$langkey", {}))
+      Slang.stub(:key_reporter, KeyReporterStub.new) do
+        error = assert_raises(ArgumentError) do
+          @snapshot.translate(:en, "bad$slangkey", [])
+        end
+        assert_match(/key name malformed/i, error.message)
+      end
+    end
+
+    def test_translate_variable_name_malformed
+      assert_equal("Welcome {user}!", @snapshot.translate(:en, "welcome", "U$ER" => "friend"))
+      Slang.stub(:key_reporter, KeyReporterStub.new) do
+        error = assert_raises(ArgumentError) do
+          @snapshot.translate(:en, "welcome", "U$ER" => "friend")
+        end
+        assert_match(/variable name malformed/i, error.message)
+      end
+    end
+
+    # def test_new_key_generation
+    #   assert_equal("MissingKey", @key_reporter.new_key("missing_key", {}, nil))
+    #   assert_equal("Some Other Key", @key_reporter.new_key("some.other.key", {}, nil))
+    #   assert_equal("ActiveRecord Model Errors", @key_reporter.new_key("active_record.model.errors", {}, nil))
+    #   assert_equal("Vars (a=Apple, b=Banana)", @key_reporter.new_key("vars", { "a" => "Apple", "b" => "Banana" }, nil))
+    # end
+
+  end
+end

data/test/test_template.rb

@@ -0,0 +1,49 @@
+# TODO: test variable_name_regex, variable_scan_regex
+require "helper"
+
+module Slang
+  class TestTemplate < Minitest::Test
+    Template = Snapshot::Template
+    parallelize_me!
+
+    def test_non_interpolation
+      t = Template.new("Hello")
+      assert_equal("Hello", t.interpolate({}))
+      assert_equal("Hello", t.interpolate("hello" => "hi"))
+    end
+
+    def test_interpolation
+      t = Template.new("Hello {name}!")
+      assert_equal("Hello Jack!", t.interpolate("name" => "Jack"))
+      assert_equal("Hello Jill!", t.interpolate("name" => "Jill", "extra" => "ignored"))
+    end
+
+    def test_complex_interpolation
+      t = Template.new("This is {name}. {name} is a {thing}.")
+      assert_equal("This is Jamie. Jamie is a cat.", t.interpolate("name" => "Jamie", "thing" => "cat"))
+    end
+
+    def test_missing_variables
+      t = Template.new("It is {weather} in {city}.")
+      result, missing_variables = t.interpolate({})
+      assert_equal("It is {weather} in {city}.", result)
+      assert_includes(missing_variables, "city")
+      assert_includes(missing_variables, "weather")
+      result, missing_variables = t.interpolate("weather" => "sunny")
+      assert_equal("It is sunny in {city}.", result)
+      assert_includes(missing_variables, "city")
+    end
+
+    def test_freezer
+      t = Template.new("A simple template.")
+      assert(t.string.frozen?)
+      assert(t.interpolate({}).frozen?)
+      t = Template.new("Hi {a}")
+      assert(t.interpolate("a" => "A").frozen?)
+      result, _missing_variables = t.interpolate({})
+      assert(result.frozen?)
+    end
+
+  end
+
+end