Module: I18n::Processes::MissingKeys

Included in:
BaseProcess
Defined in:
lib/i18n/processes/missing_keys.rb

Constant Summary collapse

MISSING_TYPES = 
{
  used: { glyph: '✗', summary: 'used in code but missing from base locale' },
  diff: { glyph: '∅', summary: 'translated in one locale but not in the other' }
}.freeze

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.missing_keys_types ⇒ Object 



11
12
13
 
# File 'lib/i18n/processes/missing_keys.rb', line 11

def self.missing_keys_types
  @missing_keys_types ||= MISSING_TYPES.keys
end

Instance Method Details

#collapse_same_key_in_locales!(forest) {|::I18n::Processes::Data::Tree::Node| ... } ⇒ Object

Parameters:

Yields:

Yield Returns:

  • (Boolean) —

    whether to collapse the node



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/i18n/processes/missing_keys.rb', line 96

def collapse_same_key_in_locales!(forest)
  locales_and_node_by_key = {}
  to_remove               = []
  forest.each do |root|
    locale = root.key
    root.keys do |key, node|
      next unless yield node
      if locales_and_node_by_key.key?(key)
        locales_and_node_by_key[key][0] << locale
      else
        locales_and_node_by_key[key] = [[locale], node]
      end
      to_remove << node
    end
  end
  forest.remove_nodes_and_emptied_ancestors! to_remove
  locales_and_node_by_key.each_with_object({}) do |(key, (locales, node)), inv|
    (inv[locales.sort.join('+')] ||= []) << [key, node]
  end.map do |locales, keys_nodes|
    keys_nodes.each do |(key, node)|
      forest["#{locales}.#{key}"] = node
    end
  end
  forest
end

#eq_base_keys(opts = {}) ⇒ Object 



30
31
32
33
34
35
 
# File 'lib/i18n/processes/missing_keys.rb', line 30

def eq_base_keys(opts = {})
  locales = Array(opts[:locales]).presence || self.locales
  (locales - [base_locale]).inject(empty_forest) do |tree, locale|
    tree.merge! equal_values_tree(locale, base_locale)
  end
end

#equal_values_tree(locale, compare_to = base_locale) ⇒ Object 



81
82
83
84
85
86
87
 
# File 'lib/i18n/processes/missing_keys.rb', line 81

def equal_values_tree(locale, compare_to = base_locale)
  base = data[compare_to].first.children
  data[locale].select_keys(root: false) do |key, node|
    other_node = base[key]
    other_node && !node.reference? && node.value == other_node.value && !ignore_key?(key, :eq_base, locale)
  end.set_root_key!(locale, type: :eq_base)
end

#locale_key_missing?(locale, key) ⇒ Boolean

Returns:

  • (Boolean) 


89
90
91
 
# File 'lib/i18n/processes/missing_keys.rb', line 89

def locale_key_missing?(locale, key)
  !key_value?(key, locale) && !external_key?(key) && !ignore_key?(key, :missing)
end

#missing_diff_forest(locales, base = base_locale) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/i18n/processes/missing_keys.rb', line 37

def missing_diff_forest(locales, base = base_locale)
  tree = empty_forest
  # present in base but not locale
  (locales - [base]).each do |locale|
    tree.merge! missing_diff_tree(locale, base)
  end
  if locales.include?(base)
    # present in locale but not base
    (self.locales - [base]).each do |locale|
      tree.merge! missing_diff_tree(base, locale)
    end
  end
  tree
end

#missing_diff_tree(locale, compared_to = base_locale) ⇒ Object

keys present in compared_to, but not in locale



59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/i18n/processes/missing_keys.rb', line 59

def missing_diff_tree(locale, compared_to = base_locale)
  data[compared_to].select_keys do |key, _node|
    locale_key_missing? locale, depluralize_key(key, compared_to)
  end.set_root_key!(locale, type: :missing_diff).keys do |_key, node|
    # change path and locale to base
    data = { locale: locale, missing_diff_locale: node.data[:locale] }
    # $stderr.puts Rainbow("data: #{data}").green
    if node.data.key?(:path)
      data[:path] = LocalePathname.replace_locale(node.data[:path], node.data[:locale], locale)
    end
    # $stderr.puts Rainbow("data: #{node.data}").green
    node.data.update data
  end
end

#missing_keys(locales: nil, types: nil, base_locale: nil) ⇒ Siblings

Parameters:

  • types (:used, :diff) (defaults to: nil) —

    all if ‘nil`.

Returns:

  • (Siblings) 


21
22
23
24
25
26
27
28
 
# File 'lib/i18n/processes/missing_keys.rb', line 21

def missing_keys(locales: nil, types: nil, base_locale: nil)
  locales ||= self.locales
  types   ||= missing_keys_types
  base = base_locale || self.base_locale
  types.inject(empty_forest) do |f, type|
    f.merge! send(:"missing_#{type}_forest", locales, base)
  end
end

#missing_keys_types ⇒ Object 



15
16
17
 
# File 'lib/i18n/processes/missing_keys.rb', line 15

def missing_keys_types
  MissingKeys.missing_keys_types
end

#missing_used_forest(locales, _base = base_locale) ⇒ Object 



52
53
54
55
56
 
# File 'lib/i18n/processes/missing_keys.rb', line 52

def missing_used_forest(locales, _base = base_locale)
  locales.inject(empty_forest) do |forest, locale|
    forest.merge! missing_used_tree(locale)
  end
end

#missing_used_tree(locale) ⇒ Object

keys used in the code missing translations in locale



75
76
77
78
79
 
# File 'lib/i18n/processes/missing_keys.rb', line 75

def missing_used_tree(locale)
  used_tree(strict: true).select_keys do |key, _node|
    locale_key_missing?(locale, key)
  end.set_root_key!(locale, type: :missing_used)
end