i18n-tasks 0.6.3 → 0.7.0

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

@@ -16,7 +16,7 @@ module I18n::Tasks::Data::Tree
     end
 
     def attributes
-      {key: @key, value: @value, data: @data, parent: @parent, children: @children}
+      {key: @key, value: @value, data: @data.try(:clone), parent: @parent, children: @children}
     end
 
     def derive(new_attr = {})
@@ -44,12 +44,6 @@ module I18n::Tasks::Data::Tree
     include Enumerable
     include Traversal
 
-    # null nodes are like nil, but do not blow up and can have children
-    # never yielded during traversal, but are passed through and can have non-null children
-    def null?
-      key.nil?
-    end
-
     def value_or_children_hash
       leaf? ? value : children.try(:to_hash)
     end
@@ -64,7 +58,7 @@ module I18n::Tasks::Data::Tree
     end
 
     def parent?
-      parent && !parent.null?
+      !!parent
     end
 
     def children?
@@ -107,7 +101,7 @@ module I18n::Tasks::Data::Tree
 
     def walk_to_root(&visitor)
       return to_enum(:walk_to_root) unless visitor
-      visitor.yield self unless self.null?
+      visitor.yield self
       parent.walk_to_root &visitor if parent?
     end
 
@@ -135,7 +129,7 @@ module I18n::Tasks::Data::Tree
     def to_hash
       @hash ||= begin
         children_hash = (children || {}).map(&:to_hash).reduce(:deep_merge) || {}
-        if null?
+        if key.nil?
           children_hash
         elsif leaf?
           {key => value}
@@ -149,7 +143,7 @@ module I18n::Tasks::Data::Tree
     delegate :to_yaml, to: :to_hash
 
     def inspect(level = 0)
-      if null?
+      if key.nil?
         label = Term::ANSIColor.dark '∅'
       else
         label = [Term::ANSIColor.color(1 + level % 15, self.key),
@@ -167,10 +161,6 @@ module I18n::Tasks::Data::Tree
     end
 
     class << self
-      def null
-        new
-      end
-
       # value can be a nested hash
       def from_key_value(key, value)
         Node.new(key: key.try(:to_s)).tap do |node|

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

@@ -24,9 +24,6 @@ module I18n::Tasks::Data::Tree
 
     def derive(new_attr = {})
       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)

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

@@ -26,6 +26,20 @@ module I18n::Tasks::Data::Tree
       self
     end
 
+    def rename_each_key!(full_key_pattern, new_key_tpl)
+      pattern_re = I18n::Tasks::KeyPatternMatching.compile_key_pattern(full_key_pattern)
+      nodes do |node|
+        next if node.full_key(root: true) !~ pattern_re
+        new_key = new_key_tpl.gsub('%{key}', node.key)
+        if node.parent == parent
+          rename_key(node.key, new_key)
+        else
+          node.parent.children.rename_key(node.key, new_key)
+        end
+      end
+      self
+    end
+
     def replace_node!(node, new_node)
       @list[@list.index(node)] = new_node
       key_to_node[new_node.key] = new_node
@@ -122,7 +136,23 @@ module I18n::Tasks::Data::Tree
       derive.merge!(nodes)
     end
 
-    def set_root_key(new_key, data = nil)
+    def subtract_keys(keys)
+      exclude = {}
+      keys.each do |full_key|
+        if (node = get full_key)
+          exclude[node] = true
+        end
+      end
+      select_nodes { |node|
+        not exclude[node] || node.children.try(:all?) { |c| exclude[c] }
+      }
+    end
+
+    def subtract_by_key(other)
+      subtract_keys other.key_names(root: true)
+    end
+
+    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
@@ -176,6 +206,7 @@ module I18n::Tasks::Data::Tree
       # this is the native i18n gem format
       def from_nested_hash(hash, opts = {})
         parse_parent_opt!(opts)
+        raise ::I18n::Tasks::CommandError.new("invalid tree #{hash.inspect}") unless hash.respond_to?(:map)
         opts[:nodes] = hash.map { |key, value| Node.from_key_value key, value }
         Siblings.new(opts)
       end
@@ -196,7 +227,6 @@ module I18n::Tasks::Data::Tree
         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

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

@@ -1,124 +1,145 @@
 # coding: utf-8
-module I18n::Tasks::Data::Tree
-  # Any Enumerable that yields nodes can mix in this module
-  module Traversal
+module I18n::Tasks
+  module Data::Tree
+    # Any Enumerable that yields nodes can mix in this module
+    module Traversal
 
-    def nodes(&block)
-      depth_first(&block)
-    end
+      def nodes(&block)
+        depth_first(&block)
+      end
 
-    def leaves(&visitor)
-      return to_enum(:leaves) unless visitor
-      nodes do |node|
-        visitor.yield(node) if node.leaf?
+      def leaves(&visitor)
+        return to_enum(:leaves) unless visitor
+        nodes do |node|
+          visitor.yield(node) if node.leaf?
+        end
+        self
       end
-      self
-    end
 
-    def levels(&block)
-      return to_enum(:levels) unless block
-      nodes    = to_nodes
-      non_null = nodes.reject(&:null?)
-      unless non_null.empty?
-        block.yield non_null
-        Nodes.new(nodes.children).levels(&block)
+      def levels(&block)
+        return to_enum(:levels) unless block
+        nodes    = to_nodes
+        unless nodes.empty?
+          block.yield nodes
+          Nodes.new(nodes.children).levels(&block)
+        end
+        self
       end
-      self
-    end
 
-    def breadth_first(&visitor)
-      return to_enum(:breadth_first) unless visitor
-      levels do |nodes|
-        nodes.each { |node| visitor.yield(node) unless node.null? }
+      def breadth_first(&visitor)
+        return to_enum(:breadth_first) unless visitor
+        levels do |nodes|
+          nodes.each { |node| visitor.yield(node) }
+        end
+        self
       end
-      self
-    end
 
-    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.depth_first(&visitor)
-        end if node.children?
-      }
-      self
-    end
+      def depth_first(&visitor)
+        return to_enum(:depth_first) unless visitor
+        each { |node|
+          visitor.yield node
+          node.children.each do |child|
+            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
+      # @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_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 key_values(opts = {})
+        opts[:root] = false unless opts.key?(:root)
+        keys(opts).map { |key, node| [key, node.value] }
+      end
 
-    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
+      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
+      #-- modify / derive
+
+      # @return Siblings
+      def select_nodes(&block)
+        tree = Siblings.new
+        each do |node|
+          if block.yield(node)
+            tree.append! node.derive(
+                             parent:   tree.parent,
+                             children: (node.children.select_nodes(&block).to_a if node.children)
+                         )
+          end
+        end
+        tree
+      end
 
-    # @return Siblings
-    def select_nodes(&block)
-      tree = Siblings.new
-      each do |node|
-        if block.yield(node)
-          tree.append! node.derive(
-              parent: tree.parent,
-              children: (node.children.select_nodes(&block).to_a if node.children)
-          )
+      # @return Siblings
+      def select_keys(opts = {}, &block)
+        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|
+              break if ok[p]
+              ok[p] = true
+            }
+          end
         end
+        select_nodes { |node|
+          ok[node]
+        }
       end
-      tree
-    end
 
-    # @return Siblings
-    def select_keys(opts = {}, &block)
-      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|
-            break if ok[p]
-            ok[p] = true
+      # @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
-      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] }
+      def grep_keys(match, opts = {})
+        select_keys(opts) do |full_key, _node|
+          match === full_key
+        end
       end
-    end
 
-    def grep_keys(match, opts = {})
-      select_keys(opts) do |full_key, _node|
-        match === full_key
+      def set_each_value!(val_pattern, key_pattern = nil, &value_proc)
+        value_proc ||= proc { |node|
+          node_value = node.value
+          human_key  = node.key.to_s.humanize
+          StringInterpolation.interpolate_soft(
+              val_pattern,
+              value: node_value,
+              human_key: human_key,
+              value_or_human_key: node_value.presence || human_key
+          )
+        }
+        if key_pattern.present?
+          pattern_re = I18n::Tasks::KeyPatternMatching.compile_key_pattern(key_pattern)
+        end
+        keys.each do |key, node|
+          next if pattern_re && key !~ pattern_re
+          node.value = value_proc.call(node)
+        end
+        self
       end
     end
   end

data/lib/i18n/tasks/google_translation.rb

@@ -1,41 +1,46 @@
 # coding: utf-8
 require 'easy_translate'
+require 'i18n/tasks/html_keys'
 
 module I18n::Tasks
   module GoogleTranslation
+    def google_translate_forest(forest, from, to)
+      list   = forest.key_values(root: true)
+      values = google_translate_list(list, to: to, from: from).map(&:last)
+      Data::Tree::Siblings.from_flat_pairs list.map(&:first).zip(values)
+    end
+
     # @param [Array] list of [key, value] pairs
-    def google_translate(list, opts)
+    def google_translate_list(list, opts)
       return [] if list.empty?
-      opts = opts.dup
-      if !opts[:key] && (key = translation_config[:api_key]).present?
-        opts[:key] = key
-      end
-      if opts[:key].blank?
-        warn_missing_api_key
-        return []
-      end
-      key_idx = {}
-      list.each_with_index { |k_v, i| key_idx[k_v[0]] = i }
-      list.group_by { |k_v|
-        !!(k_v[0] =~ /[.\-_]html\z/.freeze)
-      }.map do |html, slice|
-        t_opts = opts.merge(html ? {html: true} : {format: 'text'})
-        fetch_google_translations slice, t_opts
-      end.reduce(:+).tap { |l|
-        l.sort! { |a, b| key_idx[a[0]] <=> key_idx[b[0]] }
-      }
+      opts       = opts.dup
+      opts[:key] ||= translation_config[:api_key]
+      validate_google_translate_api_key! opts[:key]
+      key_pos = list.each_with_index.inject({}) { |idx, ((k, _v), i)| idx[k] = i; idx }
+      result  = list.group_by { |k_v| HtmlKeys.html_key? k_v[0] }.map { |is_html, list_slice|
+        fetch_google_translations list_slice, opts.merge(is_html ? {html: true} : {format: 'text'})
+      }.reduce(:+) || []
+      result.sort! { |a, b| key_pos[a[0]] <=> key_pos[b[0]] }
+      result
     end
 
     def fetch_google_translations(list, opts)
       from_values(list, EasyTranslate.translate(to_values(list), opts)).tap do |result|
         if result.blank?
-          raise CommandError.new('Google Translate returned no results. Make sure billing information is set at https://code.google.com/apis/console.')
+          raise CommandError.new(I18n.t('i18n_tasks.google_translate.errors.no_results'))
         end
       end
     end
 
     private
 
+    def validate_google_translate_api_key!(key)
+      if key.blank?
+        raise CommandError.new('Set Google API key via GOOGLE_TRANSLATE_API_KEY environment variable or translation.api_key in config/i18n-tasks.yml.
+Get the key at https://code.google.com/apis/console.')
+      end
+    end
+
     def to_values(list)
       list.map { |l| dump_value l[1] }.flatten
     end
@@ -78,10 +83,5 @@ module I18n::Tasks
       each_value = untranslated.scan(INTERPOLATION_KEY_RE).to_enum
       translated.gsub(Regexp.new(UNTRANSLATABLE_STRING, Regexp::IGNORECASE)) { each_value.next }
     end
-
-    def warn_missing_api_key
-      $stderr.puts Term::ANSIColor.red Term::ANSIColor.yellow 'Set Google API key via GOOGLE_TRANSLATE_API_KEY environmnet variable or translation.api_key in config/i18n-tasks.yml.
-Get the key at https://code.google.com/apis/console.'
-    end
   end
 end