i18n-tasks 0.4.5 → 0.5.0

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

@@ -20,17 +20,28 @@ module I18n::Tasks::Data::Tree
     end
 
     def derive(new_attr = {})
-      self.class.new(attributes.merge(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)
-      dirty!
-      @key = value.try(:to_s)
+      value = value.try(:to_s)
+      if @key != value
+        dirty!
+        parent.try(:children).try(:key_renamed, value, @key)
+        @key = value
+      end
     end
 
-    def children=(nodes_or_siblings)
+    def children=(children)
       dirty!
-      @children = Siblings.new(nodes: nodes_or_siblings, parent: self)
+      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)
@@ -47,12 +58,12 @@ module I18n::Tasks::Data::Tree
       key.nil?
     end
 
-    def hash_or_value
+    def value_or_children_hash
       leaf? ? value : children.try(:to_hash)
     end
 
     def leaf?
-      !children?
+      !children
     end
 
     attr_writer :leaf
@@ -81,11 +92,9 @@ module I18n::Tasks::Data::Tree
     # do not use directly. use parent.append(node) instead
     def parent=(value)
       return if @parent == value
-      if value
-        @parent.children.remove!(self) if @parent && @parent.children
-        @parent = value
-        dirty!
-      end
+      @parent.children.remove!(self) if @parent.try(:children) && @parent.children != value.children
+      @parent = value
+      dirty!
       @parent
     end
 
@@ -101,12 +110,10 @@ module I18n::Tasks::Data::Tree
 
     # append and reparent nodes
     def append!(nodes)
-      if nodes.any?
-        if @children
-          @children.merge!(nodes)
-        else
-          @children = Siblings.new(nodes: nodes, parent: self)
-        end
+      if @children
+        @children.merge!(nodes)
+      else
+        @children = Siblings.new(nodes: nodes, parent: self)
       end
       self
     end
@@ -116,7 +123,7 @@ module I18n::Tasks::Data::Tree
     end
 
     def full_key(opts = {})
-      root = opts.key?(:root) ? opts[:root] : true
+      root            = opts.key?(:root) ? opts[:root] : true
       @full_key       ||= {}
       @full_key[root] ||= "#{"#{parent.full_key(root: root)}." if parent? && (root || parent.parent?)}#{key}"
     end
@@ -127,6 +134,12 @@ module I18n::Tasks::Data::Tree
       parent.walk_to_root &visitor if parent?
     end
 
+    def root
+      p = nil
+      walk_to_root { |node| p = node }
+      p
+    end
+
     def walk_from_root(&visitor)
       return to_enum(:walk_from_root) unless visitor
       walk_to_root.reverse_each do |node|
@@ -138,6 +151,14 @@ module I18n::Tasks::Data::Tree
       Nodes.new([self])
     end
 
+    def to_siblings
+      if parent
+        parent.children
+      else
+        Siblings.new(nodes: [self])
+      end
+    end
+
     def to_hash
       @hash ||= begin
         children_hash = (children || {}).map(&:to_hash).reduce(:deep_merge) || {}
@@ -155,24 +176,14 @@ module I18n::Tasks::Data::Tree
     delegate :to_yaml, to: :to_hash
 
     def inspect(level = 0)
-      label =
-          if null?
-            Term::ANSIColor.dark '∅'
-          else
-            key = Term::ANSIColor.color(1 + level % 15, self.key)
-            if leaf?
-              value = Term::ANSIColor.cyan(self.value.to_s)
-              "#{key}: #{value}"
-            else
-              "#{key}"
-            end + (self.data? ? " #{self.data}" : '')
-          end
-
-      r = "#{'  ' * level}#{label}"
-      if children?
-        r += "\n" + children.map { |c| c.inspect(level + 1) }.join("\n") if children?
+      if null?
+        label = Term::ANSIColor.dark '∅'
+      else
+        label = [Term::ANSIColor.color(1 + level % 15, self.key),
+                 (": #{Term::ANSIColor.cyan(self.value.to_s)}" if leaf?),
+                 (" #{self.data}" if data?)].compact.join
       end
-      r
+      ['  ' * level, label, ("\n" + children.map { |c| c.inspect(level + 1) }.join("\n") if children?)].compact.join
     end
 
     protected

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

@@ -32,10 +32,6 @@ module I18n::Tasks::Data::Tree
       @hash ||= map(&:to_hash).reduce(:deep_merge!) || {}
     end
 
-    def key_names
-      keys(root: false).map { |key, _node| key }
-    end
-
     delegate :to_json, to: :to_hash
     delegate :to_yaml, to: :to_hash
 

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

@@ -12,8 +12,8 @@ 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) || Node.null
-      self.parent  = opts[:parent] if opts[:parent]
+      @parent      = first.try(:parent)
+      self.parent  = opts[:parent] || @parent || Node.null
     end
 
     def attributes
@@ -22,16 +22,19 @@ module I18n::Tasks::Data::Tree
 
     def parent=(node)
       return if @parent == node
-      each { |n| n.parent = node }
+      each { |root| root.parent = node }
       @parent = node
     end
 
-    alias siblings each
+    def siblings(&block)
+      each(&block)
+      self
+    end
 
     # @return [Node] by full key
     def get(full_key)
       first_key, rest = full_key.to_s.split('.', 2)
-      node = key_to_node[first_key]
+      node            = key_to_node[first_key]
       if rest && node
         node = node.children.try(:get, rest)
       end
@@ -43,7 +46,7 @@ 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]
+      child          = key_to_node[key_part]
       if rest
         unless child
           child = Node.new(key: key_part)
@@ -106,17 +109,51 @@ 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
+    end
+
     class << self
       def null
         new
       end
 
+      def build_forest(opts = {}, &block)
+        opts[:nodes] ||= []
+        parse_parent_opt!(opts)
+        forest = Siblings.new(opts)
+        block.call(forest) if block
+        forest.parent.children = 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))
+            block.call(full_key, node) if block
+            forest[full_key] = node
+          }
+        }
+      end
+
+      def from_key_names(keys, opts = {}, &block)
+        build_forest(opts) { |forest|
+          keys.each { |full_key|
+            node = Node.new(key: full_key.split('.').last)
+            block.call(full_key, node) if block
+            forest[full_key] = node
+          }
+        }
+      end
+
       # build forest from nested hash, e.g. {'es' => { 'common' => { name => 'Nombre', 'age' => 'Edad' } } }
       # this is the native i18n gem format
       def from_nested_hash(hash, opts = {})
-        opts[:parent] ||= Node.null
-        Siblings.new nodes: hash.map { |key, value| Node.from_key_value key, value },
-                     parent: opts[:parent]
+        parse_parent_opt!(opts)
+        opts[:nodes] = hash.map { |key, value| Node.from_key_value key, value }
+        Siblings.new(opts)
       end
 
       alias [] from_nested_hash
@@ -129,6 +166,14 @@ module I18n::Tasks::Data::Tree
           }
         end
       end
+
+      private
+      def parse_parent_opt!(opts)
+        opts[:parent] = Node.new(key: opts[:parent_key]) if opts[:parent_key]
+        opts[:parent] = Node.new(opts[:parent_attr]) if opts[:parent_attr]
+        opts[:parent] = Node.new(key: opts[:parent_locale], data: {locale: opts[:parent_locale]}) if opts[:parent_locale]
+        opts[:parent] ||= Node.null
+      end
     end
   end
 end

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

@@ -4,7 +4,7 @@ module I18n::Tasks::Data::Tree
   module Traversal
 
     def nodes(&block)
-      walk_depth_first(&block)
+      depth_first(&block)
     end
 
     def leaves(&visitor)
@@ -12,13 +12,7 @@ module I18n::Tasks::Data::Tree
       nodes do |node|
         visitor.yield(node) if node.leaf?
       end
-    end
-
-    # @param root include root in full key
-    def keys(opts = {}, &visitor)
-      root = opts.key?(:root) ? opts[:root] : true
-      return to_enum(:keys, root: root) unless visitor
-      leaves { |node| visitor.yield(node.full_key(root: root), node) }
+      self
     end
 
     def levels(&block)
@@ -29,47 +23,71 @@ module I18n::Tasks::Data::Tree
         block.yield non_null
         Nodes.new(nodes.children).levels(&block)
       end
+      self
     end
 
-    def walk_breadth_first(&visitor)
-      return to_enum(:walk_breadth_first) unless visitor
+    def breadth_first(&visitor)
+      return to_enum(:breadth_first) unless visitor
       levels do |nodes|
         nodes.each { |node| visitor.yield(node) unless node.null? }
       end
+      self
     end
 
-    def walk_depth_first(&visitor)
-      return to_enum(:walk_depth_first) unless visitor
+    def depth_first(&visitor)
+      return to_enum(:depth_first) unless visitor
       each { |node|
         visitor.yield node unless node.null?
         node.children.each do |child|
-          child.walk_depth_first(&visitor)
+          child.depth_first(&visitor)
         end if node.children?
       }
+      self
+    end
+
+    # @option root include root in full key
+    def keys(key_opts = {}, &visitor)
+      key_opts[:root] = false unless key_opts.key?(:root)
+      return to_enum(:keys, key_opts) unless visitor
+      leaves { |node| visitor.yield(node.full_key(key_opts), node) }
+      self
+    end
+
+
+    def key_names(opts = {})
+      opts[:root] = false unless opts.key?(:root)
+      keys(opts).map { |key, _node| key }
+    end
+
+    def key_values(opts = {})
+      opts[:root] = false unless opts.key?(:root)
+      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]}
     end
 
     #-- modify / derive
 
     # @return Siblings
     def select_nodes(&block)
-      result = Node.new(children: [])
+      tree = Siblings.new
       each do |node|
         if block.yield(node)
-          result.append!(
-              node.derive(
-                  parent:   result  ,
-                  children: (node.children.select_nodes(&block) if node.children)
-              )
+          tree.append! node.derive(
+              parent: tree.parent,
+              children: (node.children.select_nodes(&block).to_a if node.children)
           )
         end
       end
-      result.children
+      tree
     end
 
     # @return Siblings
     def select_keys(opts = {}, &block)
-      root = opts.key?(:root) ? opts[:root] : true
-      ok = {}
+      root = opts.key?(:root) ? opts[:root] : false
+      ok   = {}
       keys(root: root) do |full_key, node|
         if block.yield(full_key, node)
           node.walk_to_root { |p|
@@ -78,7 +96,28 @@ module I18n::Tasks::Data::Tree
           }
         end
       end
-      select_nodes { |node| ok[node] }
+      select_nodes { |node|
+        ok[node]
+      }
+    end
+
+
+    # @return Siblings
+    def intersect_keys(other_tree, key_opts = {}, &block)
+      if block
+        select_keys(key_opts) { |key, node|
+          other_node = other_tree[key]
+          other_node && block.call(key, node, other_node)
+        }
+      else
+        select_keys(key_opts) { |key, node| other_tree[key] }
+      end
+    end
+
+    def grep_keys(match, opts = {})
+      select_keys(opts) do |full_key, _node|
+        match === full_key
+      end
     end
   end
 end

data/lib/i18n/tasks/fill_tasks.rb

@@ -1,26 +1,34 @@
 # coding: utf-8
-module I18n::Tasks::FillTasks
-  def fill_missing_value(opts = {})
-    opts = opts.merge(
-        keys:  proc { |locale| keys_to_fill(locale) }
-    )
-    opts[:value] ||= '' unless opts[:values].present?
-    update_data opts
-  end
-
-  def fill_missing_google_translate(opts = {})
-    from = opts[:from] || base_locale
-    opts = opts.merge(
-        locales: Array(opts[:locales]) - Array(from),
-        keys:    proc { |locale| missing_tree(locale, from).key_names.map(&:to_s) },
-        values:  proc { |keys, locale|
-          google_translate(keys.zip(keys.map(&t_proc(from))), to: locale, from: from).map(&:last)
+module I18n::Tasks
+  module FillTasks
+    def fill_missing_value(opts = {})
+      value = opts[:value] || ''
+      locales_for_update(opts).each do |locale|
+        data[locale] = data[locale].merge! missing_tree(locale).keys { |key, node|
+          node.value = value.respond_to?(:call) ? value.call(key, locale, node) : value
         }
-    )
-    update_data opts
-  end
+      end
+    end
+
+    def fill_missing_google_translate(opts = {})
+      from    = opts[:from] || base_locale
+      locales = (Array(opts[:locales]).presence || self.locales) - [from]
+      locales.each do |locale|
+        keys   = missing_tree(locale, from).key_names.map(&:to_s)
+        values = google_translate(keys.zip(keys.map(&t_proc(from))), to: locale, from: from).map(&:last)
+
+        data[locale] = Data::Tree::Node.new(
+            key: locale,
+            children: Data::Tree::Siblings.from_flat_pairs(keys.zip(values))
+        ).to_siblings
+      end
+    end
 
-  def keys_to_fill(locale)
-    keys_missing_from_locale(locale).key_names
+    def locales_for_update(opts)
+      locales = (Array(opts[:locales] || opts[:locale]).presence || self.locales).map(&:to_s)
+      # make sure base_locale always comes first if present
+      locales = [base_locale] + (locales - [base_locale]) if locales.include?(base_locale)
+      locales
+    end
   end
 end