i18n-tasks 0.5.4 → 0.6.0

data/lib/i18n/tasks/console_context.rb

@@ -69,7 +69,6 @@ module I18n::Tasks
   t(key, locale)
   key_value?(key, locale)
   depluralize_key(key, locale) # convert 'hat.one' to 'hat'
-  absolutize_key(key, path)    # '.title' to 'users.index.title'
         TEXT
       end
     end

data/lib/i18n/tasks/data.rb

@@ -21,8 +21,8 @@ module I18n::Tasks
       data.t(key, locale)
     end
 
-    def tree(locale)
-      data[locale][locale].children
+    def tree(sel)
+      data[split_key(sel, 2).first][sel].try(:children)
     end
 
     def node(key, locale = base_locale)

data/lib/i18n/tasks/data/adapter/json_adapter.rb

@@ -9,14 +9,18 @@ module I18n::Tasks
 
         # @return [Hash] locale tree
         def parse(str, opts)
-          JSON.parse(str, opts || {})
+          JSON.parse(str, parse_opts(opts))
         end
 
         # @return [String]
         def dump(tree, opts)
-          JSON.generate(tree, opts || {})
+          JSON.generate(tree, parse_opts(opts))
         end
 
+        private
+        def parse_opts(opts)
+          opts.try(:symbolize_keys) || {}
+        end
       end
     end
   end

data/lib/i18n/tasks/data/file_formats.rb

@@ -13,6 +13,16 @@ module I18n
           self.class.adapter_for(path)
         end
 
+        def adapter_by_name(path)
+          self.class.adapter_by_name(path)
+        end
+
+        def adapter_dump(tree, adapter_info)
+          adapter_name, adapter_pattern, adapter = adapter_info
+          adapter_options = (config[adapter_name] || {})[:write]
+          adapter.dump(tree, adapter_options)
+        end
+
         protected
 
         def load_file(path)
@@ -24,9 +34,7 @@ module I18n
         def write_tree(path, tree)
           ::FileUtils.mkpath(File.dirname path)
           ::File.open(path, 'w') { |f|
-            adapter_name, adapter_pattern, adapter = adapter_for(path)
-            adapter_options = (config[adapter_name] || {})[:write]
-            f.write(adapter.dump(tree.to_hash, adapter_options))
+            f.write(adapter_dump(tree.to_hash, adapter_for(path)))
           }
         end
 
@@ -38,10 +46,17 @@ module I18n
           end
 
           def adapter_for(path)
-            @fn_patterns.detect { |(name, pattern, adapter)|
+            @fn_patterns.detect { |(_name, pattern, _adapter)|
               ::File.fnmatch(pattern, path)
             } or raise CommandError.new("Adapter not found for #{path}. Registered adapters: #{@fn_patterns.inspect}")
           end
+
+          def adapter_by_name(name)
+            name = name.to_s
+            @fn_patterns.detect { |(adapter_name, _pattern, _adapter)|
+              adapter_name.to_s == name
+            } or raise CommandError.new("Adapter with name #{name.inspect} not found. Registered adapters: #{@fn_patterns.inspect}")
+          end
         end
       end
     end

data/lib/i18n/tasks/data/file_system_base.rb

@@ -111,7 +111,7 @@ module I18n::Tasks
           [path.freeze, load_file(path) || {}]
         end.map do |path, data|
           Data::Tree::Siblings.from_nested_hash(data).tap do |s|
-            s.leaves { |x| x.data[:path] = path }
+            s.leaves { |x| x.data.update(path: path, locale: locale) }
           end
         end.reduce(:merge!) || Tree::Siblings.null
       end

data/lib/i18n/tasks/data/tree/node.rb

@@ -20,28 +20,19 @@ module I18n::Tasks::Data::Tree
     end
 
     def derive(new_attr = {})
-      node = self.class.new(attributes.merge(new_attr).except(:children))
-      node.children = new_attr[:children] || @children.try(:derive, parent: node)
-      node
-    end
-
-    def key=(value)
-      value = value.try(:to_s)
-      if @key != value
-        dirty!
-        parent.try(:children).try(:key_renamed, value, @key)
-        @key = value
-      end
+      self.class.new(attributes.merge(new_attr))
     end
 
     def children=(children)
+      @children = case children
+                    when Siblings
+                      children.parent == self ? children : children.derive(parent: self)
+                    when NilClass
+                      nil
+                    else
+                      Siblings.new(nodes: children, parent: self)
+                  end
       dirty!
-      if Siblings === children || children.nil?
-        @children = children
-        @children.parent = self if @children
-      else
-        @children = Siblings.new(nodes: children, parent: self)
-      end
     end
 
     def each(&block)
@@ -88,19 +79,6 @@ module I18n::Tasks::Data::Tree
       @data.present?
     end
 
-    # do not use directly. use parent.append(node) instead
-    def parent=(value)
-      return if @parent == value
-      @parent.children.remove!(self) if @parent.try(:children) && @parent.children != value.children
-      @parent = value
-      dirty!
-      @parent
-    end
-
-    def siblings
-      parent.children
-    end
-
     def get(key)
       children.get(key)
     end
@@ -151,11 +129,7 @@ module I18n::Tasks::Data::Tree
     end
 
     def to_siblings
-      if parent
-        parent.children
-      else
-        Siblings.new(nodes: [self])
-      end
+      parent.try(:children) || Siblings.new(nodes: [self])
     end
 
     def to_hash
@@ -201,7 +175,7 @@ module I18n::Tasks::Data::Tree
       def from_key_value(key, value)
         Node.new(key: key.try(:to_s)).tap do |node|
           if value.is_a?(Hash)
-            node.children = Siblings.from_nested_hash(value, parent: node)
+            node.children = Siblings.from_nested_hash(value)
           else
             node.value = value
           end

data/lib/i18n/tasks/data/tree/nodes.rb

@@ -23,8 +23,12 @@ module I18n::Tasks::Data::Tree
     end
 
     def derive(new_attr = {})
-      attr = attributes.merge(new_attr)
-      attr[:nodes] ||= @list.map(&:derive)
+      attr = attributes.except(:nodes, :parent).merge(new_attr)
+      if self.parent
+        new_attr[:parent] ||= Node.null
+      end
+      node_attr = new_attr.slice(:parent)
+      attr[:nodes] ||= @list.map { |node| node.derive(node_attr) }
       self.class.new(attr)
     end
 

data/lib/i18n/tasks/data/tree/siblings.rb

@@ -11,29 +11,31 @@ module I18n::Tasks::Data::Tree
 
     def initialize(opts = {})
       super(nodes: opts[:nodes])
-      @key_to_node = siblings.inject({}) { |h, node| h[node.key] = node; h }
-      @parent      = first.try(:parent)
-      self.parent  = opts[:parent] || @parent || Node.null
+      @parent = opts[:parent] || first.try(:parent)
+      @list.map! { |node| node.parent == @parent ? node : node.derive(parent: @parent) }
+      @key_to_node = @list.inject({}) { |h, node| h[node.key] = node; h }
     end
 
     def attributes
       super.merge(parent: @parent)
     end
 
-    def parent=(node)
-      return if @parent == node
-      each { |root| root.parent = node }
-      @parent = node
+    def rename_key(key, new_key)
+      node = key_to_node.delete(key)
+      replace_node! node, node.derive(key: new_key)
+      self
     end
 
-    def siblings(&block)
-      each(&block)
-      self
+    def replace_node!(node, new_node)
+      @list[@list.index(node)] = new_node
+      key_to_node[new_node.key] = new_node
     end
 
+    include SplitKey
+
     # @return [Node] by full key
     def get(full_key)
-      first_key, rest = full_key.to_s.split('.', 2)
+      first_key, rest = split_key(full_key, 2)
       node            = key_to_node[first_key]
       if rest && node
         node = node.children.try(:get, rest)
@@ -45,20 +47,25 @@ module I18n::Tasks::Data::Tree
 
     # add or replace node by full key
     def set(full_key, node)
-      key_part, rest = full_key.split('.', 2)
-      child          = key_to_node[key_part]
+      raise 'value should be a I18n::Tasks::Data::Tree::Node' unless node.is_a?(Node)
+      key_part, rest = split_key(full_key, 2)
+      child = key_to_node[key_part]
+
       if rest
         unless child
-          child = Node.new(key: key_part)
+          child = Node.new(key: key_part, parent: parent, children: [])
           append! child
         end
-        child.children ||= []
+        unless child.children
+          warn_add_children_to_leaf child
+          child.children = []
+        end
         child.children.set rest, node
-        dirty!
       else
         remove! child if child
         append! node
       end
+      dirty!
       node
     end
 
@@ -74,12 +81,11 @@ module I18n::Tasks::Data::Tree
     end
 
     def append!(nodes)
-      nodes.each do |node|
-        raise "node '#{node.full_key}' already has a child with key '#{node.key}'" if key_to_node.key?(node.key)
-        key_to_node[node.key] = node
-        node.parent           = parent
+      nodes = nodes.map do |node|
+        raise "already has a child with key '#{node.key}'" if key_to_node.key?(node.key)
+        key_to_node[node.key] = (node.parent == parent ? node : node.derive(parent: parent))
       end
-      super
+      super(nodes)
       self
     end
 
@@ -95,7 +101,14 @@ module I18n::Tasks::Data::Tree
           next if our == node
           our.value = node.value if node.leaf?
           our.data.merge!(node.data) if node.data?
-          our.children.merge!(node.children) if node.children?
+          if node.children?
+            if our.children
+              our.children.merge!(node.children)
+            else
+              warn_add_children_to_leaf our
+              our.children = node.children
+            end
+          end
         else
           key_to_node[node.key] = node.derive(parent: parent)
         end
@@ -109,12 +122,22 @@ module I18n::Tasks::Data::Tree
       derive.merge!(nodes)
     end
 
-    def key_renamed(new_name, old_name)
-      node = key_to_node.delete old_name
-      key_to_node[new_name] = node
+    def set_root_key(new_key, data = nil)
+      return self if empty?
+      rename_key first.key, new_key
+      leaves { |node| node.data.merge! data } if data
+      self
+    end
+
+    private
+
+    def warn_add_children_to_leaf(node)
+      ::I18n::Tasks::Logging.log_warn "'#{node.full_key}' was a leaf, now has children (value <- scope conflict)"
     end
 
     class << self
+      include SplitKey
+
       def null
         new
       end
@@ -124,14 +147,15 @@ module I18n::Tasks::Data::Tree
         parse_parent_opt!(opts)
         forest = Siblings.new(opts)
         block.call(forest) if block
-        forest.parent.children = forest
+        # forest.parent.children = forest
+        forest
       end
 
       def from_key_attr(key_attrs, opts = {}, &block)
         build_forest(opts) { |forest|
           key_attrs.each { |(full_key, attr)|
             raise "Invalid key #{full_key.inspect}" if full_key.end_with?('.')
-            node = Node.new(attr.merge(key: full_key.split('.').last))
+            node = Node.new(attr.merge(key: split_key(full_key).last))
             block.call(full_key, node) if block
             forest[full_key] = node
           }
@@ -141,7 +165,7 @@ module I18n::Tasks::Data::Tree
       def from_key_names(keys, opts = {}, &block)
         build_forest(opts) { |forest|
           keys.each { |full_key|
-            node = Node.new(key: full_key.split('.').last)
+            node = Node.new(key: split_key(full_key).last)
             block.call(full_key, node) if block
             forest[full_key] = node
           }
@@ -162,7 +186,7 @@ module I18n::Tasks::Data::Tree
       def from_flat_pairs(pairs)
         Siblings.new.tap do |siblings|
           pairs.each { |full_key, value|
-            siblings[full_key] = Node.new(key: full_key.split('.')[-1], value: value)
+            siblings[full_key] = Node.new(key: split_key(full_key).last, value: value)
           }
         end
       end

data/lib/i18n/tasks/data/tree/traversal.rb

@@ -64,8 +64,10 @@ module I18n::Tasks::Data::Tree
       keys(opts).map { |key, node| [key, node.value] }
     end
 
-    def root_key_values
-      keys(root: false).map { |key, node| [node.root.key, key, node.value]}
+    def root_key_values(sort = false)
+      result = keys(root: false).map { |key, node| [node.root.key, key, node.value]}
+      result.sort! { |a, b| a[0] != b[0] ? a[0] <=> b[0] : a[1] <=> b[1] } if sort
+      result
     end
 
     #-- modify / derive

data/lib/i18n/tasks/fill_tasks.rb

@@ -5,9 +5,12 @@ module I18n::Tasks
       value = opts[:value] || ''
       base  = opts[:base_locale] || base_locale
       locales_for_update(opts).each do |locale|
-        m = missing_tree(locale, base).keys { |key, node|
+        m = missing_keys(locales: [locale], base_locale: base).keys { |key, node|
           node.value = value.respond_to?(:call) ? value.call(key, locale, node) : value
-          node.data[:path] = LocalePathname.replace_locale(node.data[:path], base, locale) if node.data.key?(:path)
+          if node.data.key?(:path)
+            # set path hint for the router
+            node.data.update path: LocalePathname.replace_locale(node.data[:path], node.data[:locale], locale), locale: locale
+          end
         }
         data[locale] = data[locale].merge! m
       end

data/lib/i18n/tasks/ignore_keys.rb

@@ -7,7 +7,7 @@ module I18n::Tasks::IgnoreKeys
     key =~ ignore_pattern(ignore_type, locale)
   end
 
-  # @param type [:missing, :unused, :eq_base] type
+  # @param type [nil, :missing, :unused, :eq_base] type
   # @param locale [String] only when type is :eq_base
   # @return [Regexp] a regexp that matches all the keys ignored for the type (and locale)
   def ignore_pattern(type, locale = nil)

data/lib/i18n/tasks/locale_pathname.rb

@@ -3,7 +3,7 @@ module I18n::Tasks
     extend self
 
     def replace_locale(path, from, to)
-      path.try :sub, /(^|[\/.])#{from}(?=\.)/, "\\1#{to}"
+      path.try :sub, /(?<=^|[\/.])#{from}(?=\.)/, "#{to}"
     end
   end
 end

data/lib/i18n/tasks/logging.rb

@@ -1,5 +1,7 @@
 # coding: utf-8
 module I18n::Tasks::Logging
+  extend self
+
   def warn_deprecated(message)
     log_stderr Term::ANSIColor.yellow Term::ANSIColor.bold "i18n-tasks: [DEPRECATED] #{message}"
   end

data/lib/i18n/tasks/missing_keys.rb

@@ -2,55 +2,98 @@
 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 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 = base_locale)
+    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