Class: Dry::Schema::Messages::YAML

Inherits:
Abstract
  • Object
show all
Defined in:
lib/dry/schema/messages/yaml.rb

Overview

Plain YAML message backend

Constant Summary collapse

LOCALE_TOKEN = 
"%<locale>s"
TOKEN_REGEXP = 
/%{(\w*)}/.freeze
EMPTY_CONTEXT = 
Object.new.tap { |ctx|
  def ctx.context
    binding
  end
}.freeze.context

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Abstract

#call, #default_locale, #filled_lookup_paths, #lookup_paths, #namespaced, #root, #rule, #rule_lookup_paths, setting_names, #translate

Constructor Details

#initialize(data: EMPTY_HASH, config: nil) ⇒ YAML

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns a new instance of YAML.



82
83
84
85
86
87
 
# File 'lib/dry/schema/messages/yaml.rb', line 82

def initialize(data: EMPTY_HASH, config: nil)
  super()
  @data = data
  @config = config if config
  @t = proc { |key, locale: default_locale| get("%<locale>s.#{key}", locale: locale) }
end

Instance Attribute Details

#data ⇒ Hash (readonly)

Loaded localized message templates

Returns:

  • (Hash) 


28
29
30
 
# File 'lib/dry/schema/messages/yaml.rb', line 28

def data
  @data
end

#t ⇒ Proc (readonly)

Translation function

Returns:

  • (Proc) 


33
34
35
 
# File 'lib/dry/schema/messages/yaml.rb', line 33

def t
  @t
end

Class Method Details

.build(options = EMPTY_HASH) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/dry/schema/messages/yaml.rb', line 36

def self.build(options = EMPTY_HASH)
  super do |config|
    config.default_locale = :en unless config.default_locale

    config.root = -"%<locale>s.#{config.root}"

    config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
      -"%<locale>s.#{path}"
    }
  end
end

.cache ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



72
73
74
 
# File 'lib/dry/schema/messages/yaml.rb', line 72

def self.cache
  @cache ||= Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
end

.flat_hash(hash, path = EMPTY_ARRAY, keys = {}) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

rubocop: disable Metrics/PerceivedComplexity



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/dry/schema/messages/yaml.rb', line 50

def self.flat_hash(hash, path = EMPTY_ARRAY, keys = {})
  hash.each do |key, value|
    flat_hash(value, [*path, key], keys) if value.is_a?(Hash)

    if value.is_a?(String) && hash["text"] != value
      keys[[*path, key].join(DOT)] = {
        text: value,
        meta: EMPTY_HASH
      }
    elsif value.is_a?(Hash) && value["text"].is_a?(String)
      keys[[*path, key].join(DOT)] = {
        text: value["text"],
        meta: value.reject { _1.eql?("text") }.transform_keys(&:to_sym)
      }
    end
  end

  keys
end

.source_cache ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



77
78
79
 
# File 'lib/dry/schema/messages/yaml.rb', line 77

def self.source_cache
  @source_cache ||= Concurrent::Map.new
end

Instance Method Details

#get(key, options = EMPTY_HASH) ⇒ String

Get a message for the given key and its options

Parameters:

  • key (Symbol)
  • options (Hash) (defaults to: EMPTY_HASH)

Returns:

  • (String) 


109
110
111
 
# File 'lib/dry/schema/messages/yaml.rb', line 109

def get(key, options = EMPTY_HASH)
  data[evaluated_key(key, options)]
end

#interpolatable_data(key, options, **data) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



150
151
152
153
 
# File 'lib/dry/schema/messages/yaml.rb', line 150

def interpolatable_data(key, options, **data)
  tokens = evaluation_context(key, options).fetch(:tokens)
  data.select { |k,| tokens.include?(k) }
end

#interpolate(key, options, **data) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



156
157
158
159
 
# File 'lib/dry/schema/messages/yaml.rb', line 156

def interpolate(key, options, **data)
  evaluator = evaluation_context(key, options).fetch(:evaluator)
  data.empty? ? evaluator.() : evaluator.(**data)
end

#key?(key, options = EMPTY_HASH) ⇒ Boolean

Check if given key is defined

Returns:

  • (Boolean) 


118
119
120
 
# File 'lib/dry/schema/messages/yaml.rb', line 118

def key?(key, options = EMPTY_HASH)
  data.key?(evaluated_key(key, options))
end

#looked_up_paths(predicate, options) ⇒ String

Get an array of looked up paths

Parameters:

  • predicate (Symbol)
  • options (Hash)

Returns:

  • (String) 


97
98
99
 
# File 'lib/dry/schema/messages/yaml.rb', line 97

def looked_up_paths(predicate, options)
  super.map { |path| path % {locale: options[:locale] || default_locale} }
end

#merge(overrides) ⇒ Messages::I18n

Merge messages from an additional path

Parameters:

  • overrides (String)

Returns:



129
130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/dry/schema/messages/yaml.rb', line 129

def merge(overrides)
  if overrides.is_a?(Hash)
    self.class.new(
      data: data.merge(self.class.flat_hash(overrides)),
      config: config
    )
  else
    self.class.new(
      data: Array(overrides).reduce(data) { |a, e| a.merge(load_translations(e)) },
      config: config
    )
  end
end

#prepare ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



144
145
146
147
 
# File 'lib/dry/schema/messages/yaml.rb', line 144

def prepare
  @data = config.load_paths.map { |path| load_translations(path) }.reduce({}, :merge)
  self
end