Class: Dry::Schema::Messages::Abstract

Inherits:
Object
  • Object
show all
Includes:
Configurable
Defined in:
lib/dry/schema/messages/abstract.rb

Overview

Abstract class for message backends

Direct Known Subclasses

I18n, Namespaced, YAML

Class Method Summary collapse

Instance Method Summary collapse

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. 



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

def self.build(options = EMPTY_HASH)
  messages = new

  messages.configure do |config|
    options.each do |key, value|
      config.public_send(:"#{key}=", value)
    end

    config.root = "#{config.top_namespace}.#{config.root}"

    config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
      "#{config.top_namespace}.#{path}"
    }

    yield(config) if block_given?
  end

  messages.prepare
end

.setting_names ⇒ 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. 



47
48
49
 
# File 'lib/dry/schema/messages/abstract.rb', line 47

def self.setting_names
  @setting_names ||= settings.map { _1.name.to_sym }
end

Instance Method Details

#call(predicate, options) ⇒ Template Also known as: []

Retrieve a message template

Returns:



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/dry/schema/messages/abstract.rb', line 91

def call(predicate, options)
  options = {locale: default_locale, **options}
  opts = options.reject { |k,| config.lookup_options.include?(k) }
  path = lookup_paths(predicate, options).detect { |key| key?(key, opts) }

  return unless path

  result = get(path, opts)

  [
    Template.new(
      messages: self,
      key: path,
      options: opts
    ),
    result[:meta]
  ]
end

#default_locale ⇒ 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. 



169
170
171
 
# File 'lib/dry/schema/messages/abstract.rb', line 169

def default_locale
  config.default_locale
end

#filled_lookup_paths(tokens) ⇒ 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. 



141
142
143
 
# File 'lib/dry/schema/messages/abstract.rb', line 141

def filled_lookup_paths(tokens)
  config.lookup_paths.map { |path| path % tokens }
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.

Raises:

  • (NotImplementedError) 


174
175
176
 
# File 'lib/dry/schema/messages/abstract.rb', line 174

def interpolatable_data(_key, _options, **_data)
  raise NotImplementedError
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.

Raises:

  • (NotImplementedError) 


179
180
181
 
# File 'lib/dry/schema/messages/abstract.rb', line 179

def interpolate(_key, _options, **_data)
  raise NotImplementedError
end

#key?(_key, _options = EMPTY_HASH) ⇒ Boolean

Check if given key is defined

Returns:

  • (Boolean)

Raises:

  • (NotImplementedError) 


117
118
119
 
# File 'lib/dry/schema/messages/abstract.rb', line 117

def key?(_key, _options = EMPTY_HASH)
  raise NotImplementedError
end

#looked_up_paths(predicate, options) ⇒ String

Retrieve an array of looked up paths

Parameters:

  • predicate (Symbol)
  • options (Hash)

Returns:

  • (String) 


129
130
131
132
 
# File 'lib/dry/schema/messages/abstract.rb', line 129

def looked_up_paths(predicate, options)
  tokens = lookup_tokens(predicate, options)
  filled_lookup_paths(tokens)
end

#lookup_paths(predicate, options) ⇒ 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. 



135
136
137
138
 
# File 'lib/dry/schema/messages/abstract.rb', line 135

def lookup_paths(predicate, options)
  tokens = lookup_tokens(predicate, options)
  filled_lookup_paths(tokens)
end

#namespaced(namespace) ⇒ Object

Return a new message backend that will look for messages under provided namespace

Parameters:

  • namespace (Symbol, String) 


155
156
157
 
# File 'lib/dry/schema/messages/abstract.rb', line 155

def namespaced(namespace)
  Dry::Schema::Messages::Namespaced.new(namespace, self)
end

#root ⇒ Pathname

Return root path to messages file

Returns:

  • (Pathname) 


164
165
166
 
# File 'lib/dry/schema/messages/abstract.rb', line 164

def root
  config.root
end

#rule(name, options = {}) ⇒ 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
81
82
83
84
 
# File 'lib/dry/schema/messages/abstract.rb', line 78

def rule(name, options = {})
  tokens = {name: name, locale: options.fetch(:locale, default_locale)}
  path = rule_lookup_paths(tokens).detect { |key| key?(key, options) }

  rule = get(path, options) if path
  rule.is_a?(Hash) ? rule[:text] : rule
end

#rule_lookup_paths(tokens) ⇒ 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. 



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

def rule_lookup_paths(tokens)
  config.rule_lookup_paths.map { |key| key % tokens }
end

#translate(key, locale: default_locale) ⇒ 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/abstract.rb', line 73

def translate(key, locale: default_locale)
  t["#{config.top_namespace}.#{key}", locale: locale]
end