i18n-processes 0.1.0

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/data/tree/traversal'
+require 'i18n/processes/rainbow_utils'
+module I18n::Processes::Data::Tree
+  # A list of nodes
+  class Nodes
+    include Enumerable
+    include Traversal
+
+    attr_reader :list
+
+    def initialize(opts = {})
+      @list = opts[:nodes] ? opts[:nodes].to_a.clone : []
+    end
+
+    delegate :each, :present?, :empty?, :blank?, :size, :to_a, to: :@list
+
+    def to_nodes
+      self
+    end
+
+    def attributes
+      { nodes: @list }
+    end
+
+    def derive(new_attr = {})
+      attr = attributes.except(:nodes, :parent).merge(new_attr)
+      node_attr = new_attr.slice(:parent)
+      attr[:nodes] ||= @list.map { |node| node.derive(node_attr) }
+      self.class.new(attr)
+    end
+
+    def to_hash(sort = false)
+      (@hash ||= {})[sort] ||= begin
+        if sort
+          sort_by(&:key)
+        else
+          self
+        end.map { |node| node.to_hash(sort) }.reduce({}, :deep_merge!)
+      end
+    end
+
+    delegate :to_json, to: :to_hash
+    delegate :to_yaml, to: :to_hash
+
+    def inspect
+      if present?
+        map(&:inspect) * "\n"
+      else
+        I18n::Processes::RainbowUtils.faint_color('{∅}')
+      end
+    end
+
+    # methods below change state
+
+    def remove!(node)
+      @list.delete(node) || fail("#{node.full_key} not found in #{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 ? c.children.size : 0 }.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/processes/data/tree/siblings.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'i18n/processes/split_key'
+require 'i18n/processes/data/tree/nodes'
+require 'i18n/processes/data/tree/node'
+
+module I18n::Processes::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 # rubocop:disable Metrics/ClassLength
+    include ::I18n::Processes::SplitKey
+
+    attr_reader :parent, :key_to_node
+
+    def initialize(opts = {})
+      super(nodes: opts[:nodes])
+      @parent = opts[:parent] || first.try(:parent)
+      @list.map! { |node| node.parent == @parent ? node : node.derive(parent: @parent) }
+      @key_to_node = @list.each_with_object({}) { |node, h| h[node.key] = node }
+      @warn_about_add_children_to_leaf = opts.fetch(:warn_about_add_children_to_leaf, true)
+    end
+
+    def attributes
+      super.merge(parent: @parent)
+    end
+
+    def rename_key(key, new_key)
+      node = key_to_node.delete(key)
+      replace_node! node, node.derive(key: new_key)
+      self
+    end
+
+    def rename_each_key!(full_key_pattern, new_key_tpl)
+      pattern_re = I18n::Processes::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
+
+    # @param from_pattern [Regexp]
+    # @param to_pattern [Regexp]
+    # @param root [Boolean]
+    # @return {old key => new key}
+    def mv_key!(from_pattern, to_pattern, root: false) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      moved_forest = Siblings.new
+      moved_nodes = []
+      old_key_to_new_key = {}
+      nodes do |node|
+        full_key = node.full_key(root: root)
+        if from_pattern =~ full_key
+          moved_nodes << node
+          if to_pattern.empty?
+            old_key_to_new_key[full_key] = nil
+            next
+          end
+          match = $~
+          new_key = to_pattern.gsub(/\\\d+/) { |m| match[m[1..-1].to_i] }
+          old_key_to_new_key[full_key] = new_key
+          moved_forest.merge!(Siblings.new.tap do |forest|
+            forest[[(node.root.try(:key) unless root), new_key].compact.join('.')] =
+              node.derive(key: split_key(new_key).last)
+          end)
+        end
+      end
+      # Adjust references
+      # TODO: support nested references better
+      nodes do |node|
+        next unless node.reference?
+        old_target = [(node.root.key if root), node.value.to_s].compact.join('.')
+        new_target = old_key_to_new_key[old_target]
+        if new_target
+          new_target = new_target.sub(/\A[^.]*\./, '') if root
+          node.value = new_target.to_sym
+        end
+      end
+      remove_nodes_and_emptied_ancestors! moved_nodes
+      merge! moved_forest
+      old_key_to_new_key
+    end
+
+    def replace_node!(node, new_node)
+      @list[@list.index(node)]  = new_node
+      key_to_node[new_node.key] = new_node
+    end
+
+    # @return [Node] by full key
+    def get(full_key)
+      first_key, rest = split_key(full_key.to_s, 2)
+      node            = key_to_node[first_key]
+      node = node.children.try(:get, rest) if rest && node
+      node
+    end
+
+    alias [] get
+
+    # add or replace node by full key
+    def set(full_key, node)
+      fail 'value should be a I18n::Processes::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,
+            parent: parent,
+            children: [],
+            warn_about_add_children_to_leaf: @warn_add_children_to_leaf
+          )
+          append! child
+        end
+        unless child.children
+          warn_add_children_to_leaf child if @warn_about_add_children_to_leaf
+          child.children = []
+        end
+        child.children.set rest, node
+      else
+        remove! child if child
+        append! node
+      end
+      dirty!
+      node
+    end
+
+    alias []= set
+
+    # methods below change state
+
+    def remove!(node)
+      super
+      key_to_node.delete(node.key)
+      self
+    end
+
+    def append!(nodes)
+      nodes = nodes.map do |node|
+        fail "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(nodes)
+      self
+    end
+
+    def append(nodes)
+      derive.append!(nodes)
+    end
+
+    # @param on_leaves_merge [Proc] invoked when a leaf is merged with another leaf
+    def merge!(nodes, on_leaves_merge: nil)
+      nodes = Siblings.from_nested_hash(nodes) if nodes.is_a?(Hash)
+      nodes.each do |node|
+        merge_node! node, on_leaves_merge: on_leaves_merge
+      end
+      self
+    end
+
+    def merge(nodes)
+      derive.merge!(nodes)
+    end
+
+    def subtract_keys(keys)
+      remove_nodes_and_emptied_ancestors(find_nodes(keys))
+    end
+
+    def subtract_keys!(keys)
+      remove_nodes_and_emptied_ancestors!(find_nodes(keys))
+    end
+
+    def subtract_by_key(other)
+      subtract_keys other.key_names(root: true)
+    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
+      self
+    end
+
+    # @param on_leaves_merge [Proc] invoked when a leaf is merged with another leaf
+    def merge_node!(node, on_leaves_merge: nil) # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity
+      if key_to_node.key?(node.key)
+        our = key_to_node[node.key]
+        return if our == node
+        our.value = node.value if node.leaf?
+        our.data.merge!(node.data) if node.data?
+        if node.children?
+          if our.children
+            our.children.merge!(node.children)
+          else
+            warn_add_children_to_leaf our
+            our.children = node.children
+          end
+        elsif on_leaves_merge
+          on_leaves_merge.call(our, node)
+        end
+      else
+        @list << (key_to_node[node.key] = node.derive(parent: parent))
+        dirty!
+      end
+    end
+
+    # @param nodes [Enumerable] Modified in-place.
+    def remove_nodes_and_emptied_ancestors(nodes)
+      add_ancestors_that_only_contain_nodes! nodes
+      select_nodes { |node| !nodes.include?(node) }
+    end
+
+    # @param nodes [Enumerable] Modified in-place.
+    def remove_nodes_and_emptied_ancestors!(nodes)
+      add_ancestors_that_only_contain_nodes! nodes
+      select_nodes! { |node| !nodes.include?(node) }
+    end
+
+    private
+
+    def find_nodes(keys)
+      keys.each_with_object(Set.new) do |key, set|
+        node = get(key)
+        set << node if node
+      end
+    end
+
+    # Adds all the ancestors that only contain the given nodes as descendants to the given nodes.
+    # @param nodes [Set] Modified in-place.
+    def add_ancestors_that_only_contain_nodes!(nodes)
+      levels.reverse_each do |level_nodes|
+        level_nodes.each { |node| nodes << node if node.children? && node.children.all? { |c| nodes.include?(c) } }
+      end
+    end
+
+    def warn_add_children_to_leaf(node)
+      ::I18n::Processes::Logging.log_warn "'#{node.full_key}' was a leaf, now has children (value <- scope conflict)"
+    end
+
+    class << self
+      include ::I18n::Processes::SplitKey
+
+      def null
+        new
+      end
+
+      def build_forest(opts = {}, &block)
+        opts[:nodes] ||= []
+        parse_parent_opt!(opts)
+        forest = Siblings.new(opts)
+        yield(forest) if block
+        # forest.parent.children = forest
+        forest
+      end
+
+      # @param key_occurrences [I18n::Processes::Scanners::KeyOccurrences]
+      # @return [Siblings]
+      def from_key_occurrences(key_occurrences)
+        build_forest(warn_about_add_children_to_leaf: false) do |forest|
+          key_occurrences.each do |key_occurrence|
+            forest[key_occurrence.key] = ::I18n::Processes::Data::Tree::Node.new(
+              key:  split_key(key_occurrence.key).last,
+              data: { occurrences: key_occurrence.occurrences }
+            )
+          end
+        end
+      end
+
+      def from_key_attr(key_attrs, opts = {}, &block)
+        build_forest(opts) do |forest|
+          key_attrs.each do |(full_key, attr)|
+            fail "Invalid key #{full_key.inspect}" if full_key.end_with?('.')
+            node = ::I18n::Processes::Data::Tree::Node.new(attr.merge(key: split_key(full_key).last))
+            yield(full_key, node) if block
+            forest[full_key] = node
+          end
+        end
+      end
+
+      def from_key_names(keys, opts = {}, &block)
+        build_forest(opts) do |forest|
+          keys.each do |full_key|
+            node = ::I18n::Processes::Data::Tree::Node.new(key: split_key(full_key).last)
+            yield(full_key, node) if block
+            forest[full_key] = node
+          end
+        end
+      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 = {})
+        parse_parent_opt!(opts)
+        fail I18n::Processes::CommandError, "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
+
+      alias [] from_nested_hash
+
+      # build forest from [[Full Key, Value]]
+      def from_flat_pairs(pairs)
+        Siblings.new.tap do |siblings|
+          pairs.each do |full_key, value|
+            value.gsub!(/'|\n/, '') if value.include?("\n")
+            siblings[full_key] = ::I18n::Processes::Data::Tree::Node.new(key: split_key(full_key).last, value: value)
+          end
+        end
+      end
+
+      private
+
+      def parse_parent_opt!(opts)
+        opts[:parent] = ::I18n::Processes::Data::Tree::Node.new(key: opts[:parent_key]) if opts[:parent_key]
+        opts[:parent] = ::I18n::Processes::Data::Tree::Node.new(opts[:parent_attr]) if opts[:parent_attr]
+        if opts[:parent_locale]
+          opts[:parent] = ::I18n::Processes::Data::Tree::Node.new(
+            key: opts[:parent_locale], data: { locale: opts[:parent_locale] }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module I18n::Processes
+  module Data::Tree
+    # Any Enumerable that yields nodes can mix in this module
+    module Traversal # rubocop:disable Metrics/ModuleLength
+      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?
+        end
+        self
+      end
+
+      def levels(&block)
+        return to_enum(:levels) unless block
+        nodes = to_nodes
+        unless nodes.empty?
+          block.yield nodes
+          if nodes.size == 1
+            node = first
+            node.children.levels(&block) if node.children?
+          else
+            I18n::Processes::Data::Tree::Nodes.new(nodes: nodes.children).levels(&block)
+          end
+        end
+        self
+      end
+
+      def breadth_first(&visitor)
+        return to_enum(:breadth_first) unless visitor
+        levels do |nodes|
+          nodes.each { |node| visitor.yield(node) }
+        end
+        self
+      end
+
+      def depth_first(&visitor)
+        return to_enum(:depth_first) unless visitor
+        each do |node|
+          visitor.yield node
+          next unless node.children?
+          node.children.each do |child|
+            child.depth_first(&visitor)
+          end
+        end
+        self
+      end
+
+      # @option root include root in full key
+      def keys(root: false, &visitor)
+        return to_enum(:keys, root: root) unless visitor
+        leaves { |node| visitor.yield(node.full_key(root: root), 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(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_value_data(sort = false)
+        result = keys(root: false).map { |key, node| [node.root.key, key, node.value, node.data] }
+        result.sort! { |a, b| a[0] != b[0] ? a[0] <=> b[0] : a[1] <=> b[1] } if sort
+        result
+      end
+
+      #-- modify / derive
+
+      # Select the nodes for which the block returns true. Pre-order traversal.
+      # @return [Siblings] a new tree
+      def select_nodes(&block)
+        tree = Siblings.new
+        each do |node|
+          next unless block.yield(node)
+          tree.append! node.derive(
+            parent: tree.parent,
+            children: (node.children.select_nodes(&block).to_a if node.children)
+          )
+        end
+        tree
+      end
+
+      # Select the nodes for which the block returns true. Pre-order traversal.
+      # @return [Siblings] self
+      def select_nodes!(&block)
+        to_remove = []
+        each do |node|
+          if block.yield(node)
+            node.children.select_nodes!(&block) if node.children
+          else
+            # removing during each is unsafe
+            to_remove << node
+          end
+        end
+        to_remove.each { |node| remove! node }
+        self
+      end
+
+      # @return [Siblings]
+      def select_keys(root: false, &block)
+        matches = get_nodes_by_key_filter(root: root, &block)
+        select_nodes do |node|
+          matches.include?(node)
+        end
+      end
+
+      # @return [Siblings]
+      def select_keys!(root: false, &block)
+        matches = get_nodes_by_key_filter(root: root, &block)
+        select_nodes! do |node|
+          matches.include?(node)
+        end
+      end
+
+      # @return [Set<I18n::Processes::Data::Tree::Node>]
+      def get_nodes_by_key_filter(root: false, &block)
+        matches = Set.new
+        keys(root: root) do |full_key, node|
+          if block.yield(full_key, node)
+            node.walk_to_root do |p|
+              break unless matches.add?(p)
+            end
+          end
+        end
+        matches
+      end
+
+      # @return [Siblings]
+      def intersect_keys(other_tree, key_opts = {}, &block)
+        if block
+          select_keys(key_opts) do |key, node|
+            other_node = other_tree[key]
+            other_node && yield(key, node, other_node)
+          end
+        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 # rubocop:disable Style/CaseEquality
+        end
+      end
+
+      def set_each_value!(val_pattern, key_pattern = nil, &value_proc)
+        value_proc ||= proc do |node|
+          node_value = node.value
+          next node_value if node.reference?
+          human_key = ActiveSupport::Inflector.humanize(node.key.to_s)
+          full_key = node.full_key
+          default = (node.data[:occurrences] || []).detect { |o| o.default_arg.presence }.try(:default_arg)
+          StringInterpolation.interpolate_soft(
+            val_pattern,
+            value: node_value,
+            human_key: human_key,
+            key: full_key,
+            default: default,
+            value_or_human_key: node_value.presence || human_key,
+            value_or_default_or_human_key: node_value.presence || default || human_key
+          )
+        end
+        pattern_re = I18n::Processes::KeyPatternMatching.compile_key_pattern(key_pattern) if key_pattern.present?
+        keys.each do |key, node|
+          next if pattern_re && key !~ pattern_re
+          node.value = value_proc.call(node)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/i18n/processes/data.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/data/file_system'
+
+module I18n::Processes
+  module Data
+    DATA_DEFAULTS = {
+      adapter: 'I18n::Processes::Data::FileSystem'
+    }.freeze
+
+    # I18n data provider
+    # @see I18n::Processes::Data::FileSystem
+    def data
+      @data ||= begin
+        data_config = (config[:data] || {}).deep_symbolize_keys
+        data_config[:base_locale] = base_locale
+        data_config[:locales] = config[:locales]
+        adapter_class = data_config[:adapter].presence || data_config[:class].presence || DATA_DEFAULTS[:adapter]
+        adapter_class = adapter_class.to_s
+        adapter_class = 'I18n::Processes::Data::FileSystem' if adapter_class == 'file_system'
+        data_config.except!(:adapter, :class)
+        ActiveSupport::Inflector.constantize(adapter_class).new data_config
+      end
+    end
+
+    def empty_forest
+      I18n::Processes::Data::Tree::Siblings.new
+    end
+
+    def data_forest(locales = self.locales)
+      locales.inject(empty_forest) do |tree, locale|
+        tree.merge! data[locale]
+      end
+    end
+
+    def t(key, locale = base_locale)
+      data.t(key, locale)
+    end
+
+    def tree(sel)
+      data[split_key(sel, 2).first][sel].try(:children)
+    end
+
+    def node(key, locale = base_locale)
+      data[locale]["#{locale}.#{key}"]
+    end
+
+    def build_tree(hash)
+      I18n::Processes::Data::Tree::Siblings.from_nested_hash(hash)
+    end
+
+    def t_proc(locale = base_locale)
+      @t_proc         ||= {}
+      @t_proc[locale] ||= proc { |key| t(key, locale) }
+    end
+
+    # whether the value for key exists in locale (defaults: base_locale)
+    def key_value?(key, locale = base_locale)
+      !t(key, locale).nil?
+    end
+
+    def external_key?(key, locale = base_locale)
+      data.external(locale)[locale.to_s][key]
+    end
+
+    # Normalize all the locale data in the store (by writing to the store).
+    #
+    # @param [Array<String>] locales locales to normalize. Default: all.
+    # @param [Boolean] force_pattern_router Whether to use pattern router regardless of the config.
+    def normalize_store!(locales: nil, force_pattern_router: false)
+      locales ||= self.locales
+      router = force_pattern_router ? ::I18n::Processes::Data::Router::PatternRouter.new(data, data.config) : data.router
+      data.with_router(router) do
+        Array(locales).each do |target_locale|
+          # The store handles actual normalization:
+          data[target_locale] = data[target_locale]
+        end
+      end
+    end
+
+    # @param [Array<String>] locales locales to check. Default: all.
+    # @return [Array<String>] paths to data that requires normalization
+    def non_normalized_paths(locales: nil)
+      Array(locales || self.locales).flat_map { |locale| data.non_normalized_paths(locale) }
+    end
+  end
+end