i18n-youdao-tasks 0.9.37

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

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'i18n/tasks/split_key'
+require 'i18n/tasks/data/tree/nodes'
+require 'i18n/tasks/data/tree/node'
+
+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 # rubocop:disable Metrics/ClassLength
+    include ::I18n::Tasks::SplitKey
+    include ::I18n::Tasks::PluralKeys
+
+    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
+
+    # @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::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,
+            parent: parent,
+            children: [],
+            warn_about_add_children_to_leaf: @warn_about_add_children_to_leaf
+          )
+          append! child
+        end
+        unless child.children
+          conditionally_warn_add_children_to_leaf(child, [])
+          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
+      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
+            conditionally_warn_add_children_to_leaf(our, node.children)
+            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 conditionally_warn_add_children_to_leaf(node, children)
+      return unless @warn_about_add_children_to_leaf
+      return if plural_forms?(children)
+
+      warn_add_children_to_leaf(node)
+    end
+
+    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 ::I18n::Tasks::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::Tasks::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::Tasks::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::Tasks::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::Tasks::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::Tasks::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|
+            siblings[full_key] = ::I18n::Tasks::Data::Tree::Node.new(key: split_key(full_key).last, value: value)
+          end
+        end
+      end
+
+      private
+
+      def parse_parent_opt!(opts)
+        opts[:parent] = ::I18n::Tasks::Data::Tree::Node.new(key: opts[:parent_key]) if opts[:parent_key]
+        opts[:parent] = ::I18n::Tasks::Data::Tree::Node.new(opts[:parent_attr]) if opts[:parent_attr]
+        if opts[:parent_locale]
+          opts[:parent] = ::I18n::Tasks::Data::Tree::Node.new(
+            key: opts[:parent_locale], data: { locale: opts[:parent_locale] }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module I18n::Tasks
+  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
+            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(root: false)
+        keys(root: root).map { |key, _node| key }
+      end
+
+      def key_values(root: false)
+        keys(root: root).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[1] <=> b[1] : a[0] <=> b[0] } 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[1] <=> b[1] : a[0] <=> b[0] } 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)
+          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::Tasks::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.slice(:root)) do |key, node|
+            other_node = other_tree[key]
+            other_node && yield(key, node, other_node)
+          end
+        else
+          select_keys(**key_opts.slice(:root)) { |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::Tasks::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/tasks/data.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/data/file_system'
+
+module I18n::Tasks
+  module Data
+    DATA_DEFAULTS = {
+      adapter: 'I18n::Tasks::Data::FileSystem'
+    }.freeze
+
+    # I18n data provider
+    # @see I18n::Tasks::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::Tasks::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::Tasks::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::Tasks::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::Tasks::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

data/lib/i18n/tasks/html_keys.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module I18n::Tasks
+  module HtmlKeys
+    HTML_KEY_PATTERN = /[.\-_]html\z/.freeze
+    MAYBE_PLURAL_HTML_KEY_PATTERN = /[.\-_]html\.[^.]+\z/.freeze
+
+    def html_key?(full_key, locale)
+      !!(full_key =~ HTML_KEY_PATTERN ||
+          full_key =~ MAYBE_PLURAL_HTML_KEY_PATTERN &&
+              depluralize_key(split_key(full_key, 2)[1], locale) =~ HTML_KEY_PATTERN)
+    end
+  end
+end

data/lib/i18n/tasks/ignore_keys.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module I18n::Tasks::IgnoreKeys
+  # whether to ignore the key
+  # will also apply global ignore rules
+  # @param [:missing, :unused, :eq_base] ignore_type
+  def ignore_key?(key, ignore_type, locale = nil)
+    key =~ ignore_pattern(ignore_type, locale)
+  end
+
+  # @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)
+    @ignore_patterns              ||= HashWithIndifferentAccess.new
+    @ignore_patterns[type]        ||= {}
+    @ignore_patterns[type][locale] ||= begin
+      global = ignore_config.presence || []
+      type_ignore = ignore_config(type).presence || []
+      patterns = case type_ignore
+                 when Array
+                   global + type_ignore
+                 when Hash
+                   # ignore per locale
+                   global + (type_ignore['all'] || []) +
+                   type_ignore.select { |k, _v| k.to_s =~ /\b#{locale}\b/ }.values.flatten(1).compact
+                 end
+      compile_patterns_re patterns
+    end
+  end
+end

data/lib/i18n/tasks/interpolations.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module I18n::Tasks
+  module Interpolations
+    VARIABLE_REGEX = /%{[^}]+}/.freeze
+
+    def inconsistent_interpolations(locales: nil, base_locale: nil) # rubocop:disable Metrics/AbcSize
+      locales ||= self.locales
+      base_locale ||= self.base_locale
+      result = empty_forest
+
+      data[base_locale].key_values.each do |key, value|
+        next if !value.is_a?(String) || ignore_key?(key, :inconsistent_interpolations)
+
+        base_vars = Set.new(value.scan(VARIABLE_REGEX))
+        (locales - [base_locale]).each do |current_locale|
+          node = data[current_locale].first.children[key]
+          next unless node&.value.is_a?(String)
+
+          if base_vars != Set.new(node.value.scan(VARIABLE_REGEX))
+            result.merge!(node.walk_to_root.reduce(nil) { |c, p| [p.derive(children: c)] })
+          end
+        end
+      end
+
+      result.each { |root| root.data[:type] = :inconsistent_interpolations }
+      result
+    end
+  end
+end