i18n-tasks 0.3.11 → 0.4.0.beta1

data/lib/i18n/tasks/data/router/conservative_router.rb

@@ -0,0 +1,51 @@
+require 'i18n/tasks/data/router/pattern_router'
+
+module I18n::Tasks
+  module Data::Router
+    # Keep the path, or infer from base locale
+    class ConservativeRouter < PatternRouter
+      def initialize(adapter, config)
+        @adapter       = adapter
+        @base_locale   = config[:base_locale]
+        super
+      end
+
+      def route(locale, forest, &block)
+        return to_enum(:route, locale, forest) unless block
+        out = {}
+        not_found = Set.new
+        forest.keys(root: false) do |key, node|
+          locale_key = "#{locale}.#{key}"
+          path = adapter[locale][locale_key].data[:path]
+
+          # infer from base
+          unless path
+            path = base_tree["#{base_locale}.#{key}"].try(:data).try(:[], :path)
+            path = path.try :sub, /(?<=[\/.])#{base_locale}(?=\.)/, locale
+          end
+
+          if path
+            (out[path] ||= Set.new) << locale_key
+          else
+            not_found << locale_key
+          end
+        end
+        out.each do |dest, keys|
+          block.yield dest, forest.select_keys { |key, _| keys.include?(key) }
+        end
+        if not_found.present?
+          super(locale, forest.select_keys { |key, _| not_found.include?(key) }, &block)
+        end
+      end
+
+      protected
+
+      def base_tree
+        adapter[base_locale]
+      end
+
+      attr_reader :adapter, :base_locale
+    end
+  end
+end
+

data/lib/i18n/tasks/data/router/pattern_router.rb

@@ -0,0 +1,57 @@
+require 'i18n/tasks/key_pattern_matching'
+require 'i18n/tasks/data/tree/node'
+
+module I18n::Tasks
+  module Data::Router
+    # Route based on key name
+    class PatternRouter
+      include ::I18n::Tasks::KeyPatternMatching
+
+      attr_reader :routes
+      # @option data_config write [Array] of routes
+      # @example
+      #   {write:
+      #     # keys matched top to bottom
+      #     [['devise.*', 'config/locales/devise.%{locale}.yml'],
+      #     # default catch-all (same as ['*', 'config/locales/%{locale}.yml'])
+      #     'config/locales/%{locale}.yml']}
+      def initialize(_adapter, data_config)
+        @routes_config = data_config[:write]
+        @routes = compile_routes @routes_config
+      end
+
+      # Route keys to destinations
+      # @param forest [I18n::Tasks::LocaleTree::Siblings] forest roots are locales.
+      # @return [Hash] mapping of destination => [ [key, value], ... ]
+      def route(locale, forest, &block)
+        return to_enum(:route, locale, forest) unless block
+        locale = locale.to_s
+        out = {}
+        forest.keys(root: false) do |key, _node|
+          pattern, path = routes.detect { |route| route[0] =~ key }
+          if pattern
+            key_match = $~
+            path      = path % {locale: locale}
+            path.gsub!(/\\\d+/) { |m| key_match[m[1..-1].to_i] }
+            (out[path] ||= Set.new) << "#{locale}.#{key}"
+          else
+            raise "no route matches key. routes = #{@routes_config}, key = #{key}"
+          end
+        end
+        out.each do |dest, keys|
+          block.yield dest,
+                      forest.select_keys { |key, _| keys.include?(key) }
+        end
+      end
+
+      private
+
+      def compile_routes(routes)
+        routes.map { |x| x.is_a?(String) ? ['*', x] : x }.map { |x|
+          [compile_key_pattern(x[0]), x[1]]
+        }
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,199 @@
+require 'i18n/tasks/data/tree/traversal'
+require 'i18n/tasks/data/tree/siblings'
+module I18n::Tasks::Data::Tree
+  class Node
+    attr_accessor :value
+    attr_reader :key, :children, :parent
+
+    def initialize(key: nil, value: nil, data: nil, parent: nil, children: nil)
+      @key          = key.try(:to_s)
+      @value        = value
+      @data         = data
+      @parent       = parent
+      self.children = children if children
+    end
+
+    def attributes
+      {key: @key, value: @value, data: @data, parent: @parent, children: @children}
+    end
+
+    def derive(new_attr = {})
+      self.class.new(attributes.merge(new_attr))
+    end
+
+    def key=(value)
+      dirty!
+      @key = value.try(:to_s)
+    end
+
+    def children=(nodes_or_siblings)
+      dirty!
+      @children = Siblings.new(nodes: nodes_or_siblings, parent: self)
+    end
+
+    def each(&block)
+      return to_enum(:each) { 1 } unless block
+      [self].each(&block)
+    end
+
+    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 hash_or_value
+      leaf? ? value : children.try(:to_hash)
+    end
+
+    def leaf?
+      !children?
+    end
+
+    attr_writer :leaf
+
+    # a node with key nil is considered Empty. this is to allow for using these nodes instead of nils
+    def root?
+      !parent?
+    end
+
+    def parent?
+      parent && !parent.null?
+    end
+
+    def children?
+      children && children.any?
+    end
+
+    def data
+      @data ||= {}
+    end
+
+    def data?
+      @data.present?
+    end
+
+    # 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
+    end
+
+    def siblings
+      parent.children
+    end
+
+    def get(key)
+      children.get(key)
+    end
+
+    alias [] get
+
+    # append and reparent nodes
+    def append!(nodes)
+      if nodes.any?
+        if @children
+          @children.merge!(nodes)
+        else
+          @children = Siblings.new(nodes: nodes, parent: self)
+        end
+      end
+      self
+    end
+
+    def append(nodes)
+      derive.append!(nodes)
+    end
+
+    def full_key(root: true)
+      @full_key       ||= {}
+      @full_key[root] ||= "#{"#{parent.full_key(root: root)}." if parent? && (root || parent.parent?)}#{key}"
+    end
+
+    def walk_to_root(&visitor)
+      return to_enum(:walk_to_root) unless visitor
+      visitor.yield self unless self.null?
+      parent.walk_to_root &visitor if parent?
+    end
+
+    def walk_from_root(&visitor)
+      return to_enum(:walk_from_root) unless visitor
+      walk_to_root.reverse_each do |node|
+        visitor.yield node
+      end
+    end
+
+    def to_nodes
+      Nodes.new([self])
+    end
+
+    def to_hash
+      @hash ||= begin
+        children_hash = (children || {}).map(&:to_hash).reduce(:deep_merge) || {}
+        if null?
+          children_hash
+        elsif leaf?
+          {key => value}
+        else
+          {key => children_hash}
+        end
+      end
+    end
+
+    delegate :to_json, to: :to_hash
+    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: level + 1) }.join("\n") if children?
+      end
+      r
+    end
+
+    protected
+
+    def dirty!
+      @hash     = nil
+      @full_key = nil
+    end
+
+    class << self
+      def null
+        new
+      end
+
+      # value can be a nested hash
+      def from_key_value(key, value)
+        Node.new(key: key).tap do |node|
+          if value.is_a?(Hash)
+            node.children = Siblings.from_nested_hash(value, parent: node)
+          else
+            node.value = value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+require 'i18n/tasks/data/tree/traversal'
+module I18n::Tasks::Data::Tree
+  # A list of nodes
+  class Nodes
+    attr_reader :list
+
+    def initialize(nodes: [])
+      @list = nodes.to_a.clone
+    end
+
+    delegate :each, :present?, :empty?, :blank?, :size, :to_a, to: :@list
+    include Enumerable
+    include Traversal
+
+    def to_nodes
+      self
+    end
+
+    def attributes
+      {nodes: @list}
+    end
+
+    def derive(new_attr = {})
+      attr = attributes.merge(new_attr)
+      attr[:nodes] ||= @list.map(&:derive)
+      self.class.new(attr)
+    end
+
+    def to_hash
+      @hash ||= map(&:to_hash).reduce(:deep_merge!) || {}
+    end
+
+    delegate :to_json, to: :to_hash
+    delegate :to_yaml, to: :to_hash
+
+    def inspect
+      if present?
+        map(&:inspect) * "\n"
+      else
+        Term::ANSIColor.dark '∅'
+      end
+    end
+
+    # methods below change state
+
+    def remove!(node)
+      @list.delete(node) or raise "#{node.full_key} not found in #{self.inspect}"
+      dirty!
+      self
+    end
+
+    def append!(other)
+      @list += other.to_a
+      dirty!
+      self
+    end
+
+    def append(other)
+      derive.append!(other)
+    end
+
+    alias << append
+
+    def merge!(nodes)
+      @list += nodes.to_a
+      dirty!
+      self
+    end
+    alias + merge!
+
+    def children(&block)
+      return to_enum(:children) { map { |c| c.children.size }.reduce(:+) } unless block
+      each do |node|
+        node.children.each(&block) if node.children?
+      end
+    end
+
+    alias children? any?
+
+    protected
+    def dirty!
+      @hash = nil
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+require 'i18n/tasks/data/tree/traversal'
+require 'i18n/tasks/data/tree/nodes'
+module I18n::Tasks::Data::Tree
+  # Siblings represents a subtree sharing a common parent
+  # in case of an empty parent (nil) it represents a forest
+  # siblings' keys are unique
+  class Siblings < Nodes
+    attr_reader :parent, :key_to_node
+
+    def initialize(nodes: [], parent: nil)
+      super(nodes: nodes)
+      @key_to_node = siblings.inject({}) { |h, node| h[node.key] = node; h }
+      @parent      = first.try(:parent) || Node.null
+      self.parent  = parent if parent
+    end
+
+    def attributes
+      super.merge(parent: @parent)
+    end
+
+    def parent=(node)
+      return if @parent == node
+      each { |n| n.parent = node }
+      @parent = node
+    end
+
+    alias siblings each
+
+    # @return [Node] by full key
+    def get(full_key)
+      first_key, rest = full_key.to_s.split('.', 2)
+      node = key_to_node[first_key]
+      if rest && node
+        node = node.children.try(:get, rest)
+      end
+      node
+    end
+
+    alias [] get
+
+    # 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]
+      if rest
+        unless child
+          child = Node.new(key: key_part)
+          append! child
+        end
+        child.children ||= []
+        child.children.set rest, node
+        dirty!
+      else
+        remove! child if child
+        append! node
+      end
+      node
+    end
+
+    alias []= set
+
+
+    # methods below change state
+
+    def remove!(node)
+      super
+      key_to_node.delete(node.key)
+      self
+    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
+      end
+      super
+      self
+    end
+
+    def append(nodes)
+      derive.append!(nodes)
+    end
+
+    def merge!(nodes)
+      nodes = Siblings.from_nested_hash(nodes) if nodes.is_a?(Hash)
+      nodes.each do |node|
+        if key_to_node.key?(node.key)
+          our = key_to_node[node.key]
+          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?
+        else
+          key_to_node[node.key] = node.derive(parent: parent)
+        end
+      end
+      @list = key_to_node.values
+      dirty!
+      self
+    end
+
+    def merge(nodes)
+      derive.merge!(nodes)
+    end
+
+    class << self
+      def null
+        new
+      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, parent: Node.null)
+        Siblings.new nodes: hash.map { |key, value| Node.from_key_value key, value },
+                     parent: parent
+      end
+
+      alias [] from_nested_hash
+
+      # build forest from [[Full Key, Value]]
+      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)
+          }
+        end
+      end
+    end
+  end
+end