missing_keys.rb in i18n-tasks-0.6.0

- old
+ new
@@ -1,56 +1,99 @@
 # coding: utf-8
 module I18n::Tasks
   module MissingKeys
     def missing_keys_types
-      @missing_keys_types ||= [:missing_from_base, :eq_base, :missing_from_locale]
+      @missing_keys_types ||= [:used, :diff]
     end
 
-    # @param [:missing_from_base, :missing_from_locale, :eq_base] type (default nil)
+    # @param [:missing_used, :missing_diff] type (default nil)
     # @return [Siblings]
     def missing_keys(opts = {})
       locales = Array(opts[:locales]).presence || self.locales
-      types   = Array(opts[:type] || opts[:types].presence || missing_keys_types)
+      types   = (Array(opts[:types]).presence || missing_keys_types).map(&:to_s)
+      validate_missing_types! types
+      base    = opts[:base_locale] || base_locale
+      tree    = Data::Tree::Siblings.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!)
+      types.each do |type|
+        tree.merge! send(:"missing_#{type}_forest", locales, base)
+      end
+      tree
     end
 
-    def missing_tree(locale, compared_to = base_locale)
+    def eq_base_keys(opts = {})
+      locales = Array(opts[:locales]).presence || self.locales
+      (locales - [base_locale]).inject(Data::Tree::Siblings.new) { |tree, locale|
+        tree.merge! equal_values_tree(locale, base_locale)
+      }
+    end
+
+    def missing_diff_forest(locales, base = base_locale)
+      tree = Data::Tree::Siblings.new
+      # present in base but not locale
+      (locales - [base]).each { |locale|
+        tree.merge! missing_diff_tree(locale, base)
+      }
+      if locales.include?(base)
+        # present in locale but not base
+        (self.locales - [base]).each { |locale|
+          tree.merge! missing_diff_tree(base, locale).set_root_key(base)
+        }
+      end
+      tree
+    end
+
+    def missing_used_forest(locales, base = base_locale)
+      if locales.include?(base)
+        missing_used_tree(base)
+      else
+        Data::Tree::Siblings.new
+      end
+    end
+
+    def missing_tree(locale, compared_to)
       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
+        missing_used_tree locale
       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
+        missing_diff_tree locale, compared_to
       end
     end
 
-    def eq_base_tree(locale, compare_to = base_locale)
+    # keys present in compared_to, but not in locale
+    def missing_diff_tree(locale, compared_to = base_locale)
+      data[compared_to].select_keys { |key, _node|
+        locale_key_missing?(locale, key)
+      }.set_root_key(locale, type: :missing_diff).tap { |t| collapse_plural_nodes!(t) }
+    end
+
+    # keys used in the code missing translations in locale
+    def missing_used_tree(locale)
+      used_tree.select_keys { |key, _node|
+        !key_expression?(key) && locale_key_missing?(locale, key)
+      }.set_root_key(locale, type: :missing_used)
+    end
+
+    def equal_values_tree(locale, compare_to = base_locale)
       base = data[compare_to].first.children
-      set_locale_tree_type data[locale].select_keys(root: false) { |key, node|
+      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
+      }.set_root_key(locale, type: :eq_base)
     end
 
-    def set_locale_tree_type(tree, locale, type)
-      tree.siblings { |root|
-        root.key = locale
-      }.leaves { |node|
-        node.data[:type] = type
-      }
+    def locale_key_missing?(locale, key)
+      !key_value?(key, locale) && !ignore_key?(key, :missing)
+    end
+
+    private
+
+    def validate_missing_types!(types)
+      valid_types = missing_keys_types.map(&:to_s)
+      types = types.map(&:to_s)
+      invalid_types = types - valid_types
+      if invalid_types.present?
+        raise CommandError.new("Unknown types: #{invalid_types * ', '}. Valid types are: #{valid_types * ', '}.")
+      end
+      true
     end
   end
 end