babelfish-ruby 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ed8121d4c95af80ac52863c5a56764ae14d401b
+  data.tar.gz: 1c2f02c33e27f7ef0cd9149b7887f208098316d8
+SHA512:
+  metadata.gz: 307e241634ea1b3b76183e8ff5a15bdc80397ddcb127e723a1bea2070d233d21f186eeec7e1ca4dfc62ce128804f7fe4e55cded255f83011a704bb1bb14036ec
+  data.tar.gz: 5a3eb4545f188926ce0495ba435b7872321d9c05f1eb83cded96d01d956867ae4a9d5d12a0ad556ddf801e6932861fa45265b78f814d498adb1d65306b5616c1

data/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.lock
+pkg/
+doc/
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org/"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (C) 2014 by Akzhan Abdulin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,137 @@
+BabelFish - human friendly i18n for Ruby
+========================================
+
+Internationalisation with easy syntax for Ruby, Perl, node.js and browser. Classic solutions
+use multiple phrases for plurals. But we define plurals inline - that's more
+compact, and easy for programmers. Also, phrases are grouped into nested scopes,
+like in Ruby.
+
+We support all pluralisation rules from [unicode CLDR](http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html),
+version [2.0.1](http://cldr.unicode.org/index/downloads).
+
+### Installation
+
+```bash
+gem ins babelfish
+
+# or simply bundle it into your Gemfile
+```
+
+### Phrases Syntax
+
+- `#{varname}` Echoes value of variable
+- `((Singular|Plural1|Plural2)):count` Plural form
+
+example:
+
+- `А у меня в кармане #{nails_count} ((гвоздь|гвоздя|гвоздей)):nails_count`
+
+You can also omit anchor variable for plurals, by default it will be `count`.
+Thus following variants are equal:
+
+- `I have #{count} ((nail|nails))`
+- `I have #{count} ((nail|nails)):count`
+
+Also you can use variables in plural parts:
+
+- `I have ((#{count} nail|#{count} nails))`
+
+Need special zero form or overwrite any specific value? No problems:
+
+- `I have ((=0 no nails|#{count} nail|#{count} nails))`
+
+
+##### Escape chars
+
+If you need `#{`, `((`, `|` or `))` somewhere in text, where it can be considered
+as markup part - just escape them with `\`.
+
+
+##### Example with YAML
+
+As BabelFish flatten scopes, it's really fun and nice to store translations in
+YAML files:
+
+```yaml
+---
+ru-RU:
+  profile: Профиль
+  forums: Форумы
+  apps:
+    forums:
+      new_topic: Новая тема
+      last_post:
+        title : Последнее сообщение
+        by : от
+  demo:
+    apples: На столе лежит #{count} ((яблоко|яблока|яблок))
+```
+
+### Usage
+
+```ruby
+# Create new instance of Babelfish with default language/locale: 'en-GB'
+require 'babelfish'
+i18n = new Babelfish('en-GB');
+
+
+# Fill in some phrases
+i18n.addPhrase('en-GB', 'demo.hello',         'Hello, #{user.name}.');
+i18n.addPhrase('en-GB', 'demo.conv.wazup',    'Whats up?');
+i18n.addPhrase('en-GB', 'demo.conv.alright',  'Alright, man!');
+i18n.addPhrase('en-GB', 'demo.coerce',        'Total: #{count}.');
+
+i18n.addPhrase('ru-RU', 'demo.hello',         'Привет, #{user.name}.');
+i18n.addPhrase('ru-RU', 'demo.conv.wazup',    'Как дела?');
+
+i18n.addPhrase('uk-UA', 'demo.hello',         'Здоровенькі були, #{user.name}.');
+
+
+# Set locale fallback to use the most appropriate translation when possible
+i18n.setFallback('uk-UA', 'ru-RU');
+
+
+# Translate
+var params = {user: {name: 'ixti'}};
+
+i18n.t('ru-RU', 'demo.hello', params);  // -> 'Привет, ixti.'
+i18n.t('ru-RU', 'demo.conv.wazup');     // -> 'Как дела?'
+i18n.t('ru-RU', 'demo.conv.alright');   // -> 'Alright, man!'
+
+i18n.t('uk-UA', 'demo.hello', params);  // -> 'Здоровенькі були, ixti.'
+i18n.t('uk-UA', 'demo.conv.wazup');     // -> 'Как дела?'
+i18n.t('uk-UA', 'demo.conv.alright');   // -> 'Alright, man!'
+
+# When params is number or strings, it will be coerced to
+# `{ count: XXX, value: XXX }` - use any of those in phrase.
+i18n.t('en-GB', 'demo.coerce', 5);      // -> 'Total: 5.'
+
+
+# You may wish to "dump" translations to load in browser later
+# Dump will include all fallback translations and fallback rules
+var locale_dump = i18n.stringify('ru-RU');
+
+var i18n_new = require('babelfish')('en-GB'); // init without `new` also works
+i18n_new.load(locale_dump);
+
+
+# Use objects instead of strings (object/array/number/boolean) - can be
+# useful to prepare bulk data for external libraries.
+# Note, only JSON-supported types are ok (no date & regex)
+i18n.addPhrase('en-GB', 'demo.boolean',  true);
+i18n.addPhrase('en-GB', 'demo.number',   123);
+i18n.addPhrase('en-GB', 'demo.array',    [1, 2, 3]);
+# fourth param required for hashes (objects) to disable flattening,
+# other types are autodetected
+i18n.addPhrase('en-GB', 'demo.array',    { foo:1, bar:"2" }, false);
+```
+
+
+### Implementations in other languages
+
+- Perl - [Locale::Babelfish](https://metacpan.org/pod/Locale::Babelfish)
+
+
+### License
+
+View the [LICENSE](https://github.com/regru/babelfish-ruby/blob/master/LICENSE) file (MIT).

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake'
+
+APP_ROOT = File.dirname(__FILE__).freeze
+
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov = true
+  t.ruby_opts = '-w'
+  t.rcov_opts = %q[-Ilib --exclude "spec/*,gems/*"]
+end
+
+task :default => :spec
+
+require 'yard'
+
+YARD::Rake::YardocTask.new do |yard|
+  version = File.exists?('VERSION') ? IO.read('VERSION') : ""
+  yard.options << "--title='git-commit-notifier #{version}'"
+end

data/babelfish.gemspec

@@ -0,0 +1,27 @@
+GEM_ROOT = File.dirname(__FILE__).freeze  unless defined?(GEM_ROOT)
+
+lib_path = File.expand_path('lib', GEM_ROOT)
+$LOAD_PATH.unshift(lib_path)  unless $LOAD_PATH.include? lib_path
+
+require 'babelfish/version'
+
+Gem::Specification.new do |s|
+  s.name     = "babelfish-ruby"
+  s.version  = Babelfish::VERSION.dup
+  s.date = Time.now.strftime('%Y-%m-%d')
+  s.summary  = "Babelfish syntax internationalization module."
+  s.email    = "akzhan.abdulin@gmail.com"
+  s.homepage = "http://regru.github.io/babelfish-ruby/"
+  s.description = "Human friendly i18n in both JavaScript, Ruby, Perl whatever."
+  s.has_rdoc = true
+  s.author  = "Akzhan Abdulin"
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency('rake', ['~> 0.8',  '!= 0.9.0'])
+  s.add_development_dependency('yard', '~> 0.8.7')
+  s.add_development_dependency('redcarpet', '~> 3.0')
+  s.add_development_dependency(%q<rspec>, [">= 3.0"])
+end
+

data/lib/babelfish-ruby.rb

@@ -0,0 +1,2 @@
+# -*- encoding : utf-8 -*-
+require_relative 'babelfish'

data/lib/babelfish.rb

@@ -0,0 +1,289 @@
+# -*- encoding : utf-8 -*-
+require 'find'
+require 'yaml'
+
+require 'babelfish/phrase/string_to_compile'
+require 'babelfish/phrase/parser'
+require 'babelfish/phrase/compiler'
+
+class Babelfish
+    attr_accessor :dictionaries, :dirs, :suffix, :default_locale
+    attr_accessor :fallbacks, :fallback_cache
+    attr_accessor :file_filter, :watch, :watchers
+    attr_accessor :compiler, :parser
+    attr_accessor :_cfg
+
+    def _built_config(cfg)
+        {
+            dictionaries:   {},
+            dirs:           [ "./locales" ],
+            fallbacks:      {},
+            fallback_cache: {},
+            suffix:         cfg[:suffix] || 'yml',
+            default_locale: cfg[:default_locale] || 'en_US',
+            watch:          cfg[:watch] || 0,
+            watchers:       {},
+        }.merge( cfg || {} )
+    end
+
+    def initialize(cfg = {})
+        cfg = {
+            _cfg: cfg,
+        }.merge( _built_config(cfg) )
+
+        cfg.keys.each do |key|
+            send("#{key}=", cfg[key])  if respond_to?("#{key}=")
+        end
+
+        self.parser = Babelfish::Phrase::Parser.new
+        self.compiler = Babelfish::Phrase::Compiler.new
+
+        load_dictionaries( file_filter )
+        self.locale = default_locale
+    end
+
+    def locale
+        @locale
+    end
+
+    def locale=(new_locale)
+        @locale = detect_locale( new_locale )
+    end
+
+    def watch?
+        !! watch
+    end
+
+    def prepare_to_compile
+        dictionaries.each_pair do |locale, dic|
+            dic.each_pair do |key, value|
+                if phrase_need_compilation( value, key )
+                    dic[key] = Babelfish::Phrase::StringToCompile.new(value) # lazy compile
+                    #dic[key] = compiler.compile( parser.parse(value, locale) );
+                end
+            end
+        end
+        true
+    end
+
+
+    def detect_locale(locale)
+        return locale  if dictionaries.has_key?(locale)
+        alt_locale = dictionaries.keys.find { |loc| loc =~ /^#{Regexp.escape(locale)}[\-_]/i }
+        if alt_locale && dictionaries.has_key?(alt_locale)
+            # Lets locale dictionary will refer to alt locale dictinary.
+            # This speeds up all subsequent calls of t/detect/exists on this locale.
+            dictionaries[locale] = dictionaries[alt_locale]
+
+            fallback_cache[locale] = fallback_cache[alt_locale]  if fallback_cache.has_key?(alt_locale)
+
+            fallbacks[locale] = fallbacks[alt_locale]  if fallbacks.has_key?(alt_locale)
+
+            return locale
+        end
+        return default_locale  if dictionaries.has_key?(default_locale)
+        raise "bad locale: #{locale} and bad default_locale: #{default_locale}."
+    end
+
+
+    def load_dictionaries(filter)
+        dirs.each do |dir|
+            fdir = File.absolute_path( dir )
+            Find.find(dir) do |file|
+                file_path = File.absolute_path(file)
+                next  unless FileTest.file? file_path
+                return  if filter && !filter( file_path )
+                directories, base = File.split( file_path )
+                tmp = base.split('.')
+                cur_suffix = tmp.pop
+                return  if cur_suffix != suffix
+                locale = tmp.pop
+                dictname = tmp.join('.')
+                subdir = directories
+                if subdir =~ /^#{Regexp.escape(fdir)}[\\\/](.+)$/
+                    dictname = "#{$1}#{dictname}"
+                end
+                _load_dictionary( dictname, locale, file )
+            end
+        end
+        prepare_to_compile
+    end
+
+    def _load_dictionary( dictname, lang, file )
+        dictionaries[lang] ||= {}
+
+        yaml = YAML.load_file( file )
+        _flat_hash_keys( yaml, "#{dictname}.", dictionaries[lang] )
+
+        return  unless watch?
+        watchers[file] = File.mtime(file)
+    end
+
+    def phrase_need_compilation( phrase, key )
+        raise "L10N: #{key} is undef"  if phrase.nil?
+        return phrase.kind_of?(String) && phrase =~ /(?:\(\(|\#\{|\\\\)/
+    end
+
+    def on_watcher_change
+        _cfg.keys.each do |key|
+            send("#{key}=", nil)  if respond_to?("#{key}=")
+        end
+
+        new_cfg = _built_config( _cfg )
+        new_cfg.keys.each do |key|
+            send("#{key}=", new_cfg[key])  if respond_to?("#{key}=")
+        end
+        load_dictionaries
+        self.locale = default_locale
+    end
+
+    def look_for_watchers
+        ok = true
+        watchers.each_pair do | file, mtime |
+            new_mtime = File.mtime(file)
+            if mtime.nil? || new_mtime.nil? || new_mtime != mtime
+                ok = false
+                break
+            end
+        end
+        return  if ok;
+        on_watcher_change
+    end
+
+    def t_or_undef( dictname_key, params = nil, custom_locale = nil )
+        # disallow non-ASCII keys
+        raise("wrong dictname_key: #{dictname_key}")  if dictname_key =~ /\P{ASCII}/;
+
+        look_for_watchers  if watch?
+
+        _locale = custom_locale ? detect_locale( custom_locale ) : self.locale
+
+        r = dictionaries[_locale][dictname_key]
+
+        unless r.nil?
+            if r.kind_of?(Babelfish::Phrase::StringToCompile)
+                dictionaries[_locale][dictname_key] = r = compiler.compile(
+                    parser.parse( r, _locale ),
+                )
+            end
+         # fallbacks
+        else
+            fallback_cache[_locale] ||= {}
+            #  Cache can contain undef, as unexistent value.
+            if fallback_cache[_locale].has_key?(dictname_key)
+                r = fallback_cache[_locale][dictname_key]
+            else
+                fallback_locales = fallbacks[_locale] || []
+                fallback_locales.each do |fallback|
+                    r = dictionaries[fallback][dictname_key]
+                    unless r.nil?
+                        if r.kind_of?(Babelfish::Phrase::StringToCompile)
+                            dictionaries[fallback][dictname_key] = r = compiler.compile(
+                                parser.parse( r, fallback ),
+                            )
+                        end
+                        break
+                    end
+                end
+                fallback_cache[_locale][dictname_key] = r;
+            end
+        end
+
+        if r.kind_of?(Proc)
+            flat_params = {}
+            # Convert parameters hash to flat form like "key.subkey"
+            unless params.nil?
+                # Scalar interpreted as { count => scalar, value => scalar }.
+                unless params.kind_of?(Hash)
+                    flat_params = {
+                        'count' => params,
+                        'value' => params,
+                    }
+                else
+                    _flat_hash_keys( params, '', flat_params )
+                end
+            end
+
+            return r.call( flat_params );
+        end
+        return r
+    end
+
+    def t( dictname_key, params = nil, custom_locale = nil )
+        t_or_undef( dictname_key, params, custom_locale ) || "[#{dictname_key}]";
+    end
+
+    def has_any_value( dictname_key, custom_locale = nil )
+
+        # disallow non-ASCII keys
+        raise("wrong dictname_key: #{dictname_key}")  if dictname_key =~ /\P{ASCII}/;
+
+        look_for_watchers  if watch?
+
+        _locale = custom_locale ? detect_locale( custom_locale ) : self.locale
+
+        return true  if dictionaries[_locale].has_key?(dictname_key)
+
+        fallback_cache[_locale] ||= {}
+        return ! fallback_cache[_locale][dictname_key].nil?  if fallback_cache[_locale].has_key?(dictname_key)
+
+        fallback_locales = fallbacks[_locale] || []
+        return true  if fallback_locales.find do |fallback|
+            ! dictionaries[fallback][dictname_key].nil?
+        end
+
+        return false
+    end
+
+    def set_fallback( locale, fallback_locales )
+        return  unless fallback_locales && fallback_locales.size
+
+        _locale = detect_locale( locale )
+
+        fallbacks[_locale] = fallback_locales
+        fallback_cache.delete(_locale)
+
+        return true
+    end
+
+    def _flat_hash_keys( hash, prefix, store )
+        hash.each_pair do | key, value |
+            if value.kind_of?(Hash)
+                _flat_hash_keys( value, "#{prefix}#{key}.", store )
+            else
+                store["#{prefix}#{key}"] = value.kind_of?(Symbol) ? value.to_s : value
+            end
+        end
+        return true
+    end
+
+    def addPhrase( locale, phrase, translation, flatten_level = Float::INFINITY)
+        fl = Float::INFINITY
+        case flatten_level
+        when FalseClass
+            fl = 0
+        when TrueClass
+            fl = Float::INFINITY
+        when FixNum, Float
+            fl = flatten_level.to_i
+            fl = 0  if fl < 0
+        else
+            fl = Float::INFINITY;
+        end
+
+        if translation.kind_of?(Hash) && fl > 0
+            translation.each_pair do | key, val |
+                addPhrase( locale, "#{phrase}.#{key}", val, fl - 1 )
+            end
+            return
+        end
+
+        if  phrase_need_compilation(translation)
+            dictionaries[locale][phrase] = Babelfish::Phrase::StringToCompile.new(translation)
+        else
+            dictionaries[locale][phrase] = translation
+        end
+
+        self.fallback_cache = {}
+    end
+end