Module: CouchI18n::Backend::Implementation

Includes:
I18n::Backend::Base, I18n::Backend::Flatten
Included in:
CouchI18n::Backend
Defined in:
lib/couch_i18n/backend.rb

Overview

This is a basic backend for key value stores. It receives on initialization the store, which should respond to three methods:

  • store#[](key) - Used to get a value

  • store#[]=(key, value) - Used to set a value

  • store#keys - Used to get all keys

Since these stores only supports string, all values are converted to JSON before being stored, allowing it to also store booleans, hashes and arrays. However, this store does not support Procs.

As the ActiveRecord backend, Symbols are just supported when loading translations from the filesystem or through explicit store translations.

Also, avoid calling I18n.available_locales since it’s a somehow expensive operation in most stores.

Example

To setup I18n to use TokyoCabinet in memory is quite straightforward:

require 'rufus/tokyo/cabinet' # gem install rufus-tokyo
I18n.backend = I18n::Backend::KeyValue.new(Rufus::Tokyo::Cabinet.new('*'))

Performance

You may make this backend even faster by including the Memoize module. However, notice that you should properly clear the cache if you change values directly in the key-store.

Subtrees

In most backends, you are allowed to retrieve part of a translation tree:

I18n.backend.store_translations :en, :foo => { :bar => :baz }
I18n.t "foo" #=> { :bar => :baz }

This backend supports this feature by default, but it slows down the storage of new data considerably and makes hard to delete entries. That said, you are allowed to disable the storage of subtrees on initialization:

I18n::Backend::KeyValue.new(@store, false)

This is useful if you are using a KeyValue backend chained to a Simple backend.

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#store ⇒ Object

Returns the value of attribute store.



50
51
52
 
# File 'lib/couch_i18n/backend.rb', line 50

def store
  @store
end

Instance Method Details

#available_locales ⇒ Object 



76
77
78
79
80
81
82
 
# File 'lib/couch_i18n/backend.rb', line 76

def available_locales
  locales = @store.keys.map { |k| k =~ /\./; $` }
  locales.uniq!
  locales.compact!
  locales.map! { |k| k.to_sym }
  locales
end

#initialize(store, subtrees = true) ⇒ Object 



53
54
55
 
# File 'lib/couch_i18n/backend.rb', line 53

def initialize(store, subtrees=true)
  @store, @subtrees = store, subtrees
end

#store_translations(locale, data, options = {}) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/couch_i18n/backend.rb', line 57

def store_translations(locale, data, options = {})
  escape = options.fetch(:escape, true)
  flatten_translations(locale, data, escape, @subtrees).each do |key, value|
    key = "#{locale}.#{key}"

    case value
    when Hash
      if @subtrees && (old_value = @store[key])
        old_value = ActiveSupport::JSON.decode(old_value)
        value = old_value.deep_symbolize_keys.deep_merge!(value) if old_value.is_a?(Hash)
      end
    when Proc
      raise "Key-value stores cannot handle procs"
    end

    @store[key] = ActiveSupport::JSON.encode(value) unless value.is_a?(Symbol)
  end
end