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, #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.



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

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) 


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

def data
  @data
end

#t ⇒ Proc (readonly)

Translation function

Returns:

  • (Proc) 


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

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. 



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

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. 



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

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



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

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. 



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

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) 


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

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. 



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

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. 



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

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) 


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

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) 


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

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:



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

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. 



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

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