missing_keys.rb in i18n-tasks-0.5.0

- old
+ new
@@ -1,61 +1,56 @@
 # coding: utf-8
 module I18n::Tasks
   module MissingKeys
+    def missing_keys_types
+      @missing_keys_types ||= [:missing_from_base, :eq_base, :missing_from_locale]
+    end
+
     # @param [:missing_from_base, :missing_from_locale, :eq_base] type (default nil)
-    # @return [KeyGroup]
+    # @return [Siblings]
     def missing_keys(opts = {})
       locales = Array(opts[:locales]).presence || self.locales
-      type    = opts[:type]
-      unless type
-        types = opts[:types].presence || missing_keys_types
-        opts  = opts.except(:types).merge(locales: locales)
-        return types.map { |t| missing_keys(opts.merge(type: t)) }.reduce(:+)
-      end
+      types   = Array(opts[:type] || opts[:types].presence || missing_keys_types)
 
-      if type.to_s == 'missing_from_base'
-        keys = keys_missing_from_base if locales.include?(base_locale)
-      else
-        keys = non_base_locales(locales).map { |locale|
-          send("keys_#{type}", locale)
-        }.reduce(:+)
-      end
-      keys || KeyGroup.new([])
+      types.map { |type|
+        case type.to_s
+          when 'missing_from_base'
+            missing_tree(base_locale) if locales.include?(base_locale)
+          when 'missing_from_locale'
+            non_base_locales(locales).map { |locale| missing_tree(locale) }.reduce(:merge!)
+          when 'eq_base'
+            non_base_locales(locales).map { |locale| eq_base_tree(locale) }.reduce(:merge!)
+        end
+      }.compact.reduce(:merge!)
     end
 
-    def missing_keys_types
-      @missing_keys_types ||= [:missing_from_base, :eq_base, :missing_from_locale]
-    end
-
-    # @return [KeyGroup] missing keys, i.e. key that are in the code but are not in the base locale data
-    def keys_missing_from_base
-      @keys_missing_from_base ||= begin
-        keys = used_keys.keys.reject { |k|
-          key = k.key
-          k.expr? || key_value?(key, base_locale) || ignore_key?(key, :missing)
-        }.map(&:clone_orphan)
-        KeyGroup.new keys, type: :missing_from_base, locale: base_locale
+    def missing_tree(locale, compared_to = base_locale)
+      if locale == compared_to
+        # keys used, but not present in locale
+        set_locale_tree_type used_tree.select_keys { |key, node|
+          !(key_expression?(key) || key_value?(key, locale) || ignore_key?(key, :missing))
+        }, locale, :missing_from_base
+      else
+        # keys present in compared_to, but not in locale
+        collapse_plural_nodes! set_locale_tree_type data[compared_to].select_keys { |key, node|
+          !key_value?(key, locale) && !ignore_key?(key, :missing)
+        }, locale, :missing_from_locale
       end
     end
 
-    # @return [KeyGroup] keys missing (nil or blank?) in locale but present in base
-    def keys_missing_from_locale(locale)
-      return keys_missing_from_base if locale == base_locale
-      @keys_missing_from_locale         ||= {}
-      @keys_missing_from_locale[locale] ||= begin
-        keys = missing_tree(locale).key_names.map { |key| depluralize_key(key, locale) }.uniq
-        KeyGroup.new keys, type: :missing_from_locale, locale: locale
-      end
+    def eq_base_tree(locale, compare_to = base_locale)
+      base = data[compare_to].first.children
+      set_locale_tree_type data[locale].select_keys(root: false) { |key, node|
+        other_node = base[key]
+        other_node && node.value == other_node.value && !ignore_key?(key, :eq_base, locale)
+      }, locale, :eq_base
     end
 
-    # @return [KeyGroup] keys missing value (but present in base)
-    def keys_eq_base(locale)
-      @keys_eq_base         ||= {}
-      @keys_eq_base[locale] ||= begin
-        keys = data[base_locale].keys(root: false).map { |key, node|
-          key if node.value == t(key, locale) && !ignore_key?(key, :eq_base, locale)
-        }.compact
-        KeyGroup.new keys, type: :eq_base, locale: locale
-      end
+    def set_locale_tree_type(tree, locale, type)
+      tree.siblings { |root|
+        root.key = locale
+      }.leaves { |node|
+        node.data[:type] = type
+      }
     end
   end
 end