i18n-tasks 1.1.2 → 1.2.0

data/benchmarks/tree_bench.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+# Micro-benchmarks for the tree data structure operations.
+#
+# These isolate pure tree performance with no I/O, making them useful for
+# detecting regressions in the tree algorithms themselves.
+#
+# Usage:
+#   bundle exec ruby benchmarks/tree_bench.rb
+#   bundle exec ruby benchmarks/tree_bench.rb --save
+#   bundle exec ruby benchmarks/tree_bench.rb --compare
+#   bundle exec ruby benchmarks/tree_bench.rb --memory  # include memory profiles
+
+require_relative "bench_helper"
+
+require "i18n/tasks/data/tree/siblings"
+require "i18n/tasks/data/tree/node"
+
+SAVE_RESULTS = ARGV.include?("--save")
+COMPARE_RESULTS = ARGV.include?("--compare")
+MEMORY_PROFILE = ARGV.include?("--memory")
+
+Siblings = I18n::Tasks::Data::Tree::Siblings
+
+# ---------------------------------------------------------------------------
+# Helpers to build in-memory trees of various sizes without touching disk
+# ---------------------------------------------------------------------------
+
+def flat_keys(count)
+  sections = %w[users posts comments orders products admin auth errors shared mailers]
+  Array.new(count) do |i|
+    section = sections[i % sections.size]
+    "#{section}.group_#{i / sections.size}.item_#{i}.label"
+  end
+end
+
+def build_siblings(key_count)
+  Siblings.from_key_names(flat_keys(key_count))
+end
+
+def build_nested_hash(key_count, locale = "en")
+  keys = flat_keys(key_count)
+  hash = {locale => {}}
+  keys.each_with_index do |key, i|
+    parts = key.split(".")
+    node = hash[locale]
+    parts[0..-2].each do |p|
+      node[p] ||= {}
+      node = node[p]
+    end
+    node[parts.last] = "value_#{i}"
+  end
+  hash
+end
+
+# Pre-build fixtures so allocation is not counted
+SMALL_KEYS = flat_keys(200).freeze
+MEDIUM_KEYS = flat_keys(2_000).freeze
+LARGE_KEYS = flat_keys(8_000).freeze
+
+SMALL_HASH = build_nested_hash(200).freeze
+MEDIUM_HASH = build_nested_hash(2_000).freeze
+
+SMALL_TREE = build_siblings(200).freeze
+MEDIUM_TREE = build_siblings(2_000).freeze
+LARGE_TREE = build_siblings(8_000).freeze
+
+SMALL_TREE_B = build_siblings(200).freeze
+MEDIUM_TREE_B = build_siblings(2_000).freeze
+
+# ---------------------------------------------------------------------------
+# Construction benchmarks
+# ---------------------------------------------------------------------------
+
+BenchHelper.header("Tree construction")
+
+construction_suite = Benchmark.ips do |x|
+  x.config(warmup: 3, time: 10)
+
+  x.report("from_key_names (200 keys)") do
+    Siblings.from_key_names(SMALL_KEYS)
+  end
+
+  x.report("from_key_names (2k keys)") do
+    Siblings.from_key_names(MEDIUM_KEYS)
+  end
+
+  x.report("from_key_names (8k keys)") do
+    Siblings.from_key_names(LARGE_KEYS)
+  end
+
+  x.report("from_nested_hash (200 keys)") do
+    Siblings.from_nested_hash(SMALL_HASH)
+  end
+
+  x.report("from_nested_hash (2k keys)") do
+    Siblings.from_nested_hash(MEDIUM_HASH)
+  end
+
+  x.compare!
+end
+
+# ---------------------------------------------------------------------------
+# Merge benchmarks
+# ---------------------------------------------------------------------------
+
+BenchHelper.header("Tree merge")
+
+merge_suite = Benchmark.ips do |x|
+  x.config(warmup: 3, time: 10)
+
+  x.report("merge! (200 into 200 keys)") do
+    SMALL_TREE.derive.merge!(SMALL_TREE_B)
+  end
+
+  x.report("merge! (2k into 2k keys)") do
+    MEDIUM_TREE.derive.merge!(MEDIUM_TREE_B)
+  end
+
+  x.compare!
+end
+
+# ---------------------------------------------------------------------------
+# Traversal benchmarks
+# ---------------------------------------------------------------------------
+
+BenchHelper.header("Tree traversal")
+
+traversal_suite = Benchmark.ips do |x|
+  x.config(warmup: 3, time: 10)
+
+  x.report("leaves (2k keys)") do
+    MEDIUM_TREE.leaves.to_a
+  end
+
+  x.report("key_names (2k keys)") do
+    MEDIUM_TREE.key_names
+  end
+
+  x.report("key_names (8k keys)") do
+    LARGE_TREE.key_names
+  end
+
+  x.report("select_keys (2k, match half)") do
+    i = 0
+    MEDIUM_TREE.select_keys { |_key, _node| (i += 1).odd? }
+  end
+
+  x.report("nodes block iteration (2k keys)") do
+    MEDIUM_TREE.nodes.to_a
+  end
+
+  x.compare!
+end
+
+# ---------------------------------------------------------------------------
+# subtract_by_key! benchmark
+# ---------------------------------------------------------------------------
+
+BenchHelper.header("Tree subtract")
+
+subtract_suite = Benchmark.ips do |x|
+  x.config(warmup: 3, time: 10)
+
+  x.report("subtract_by_key! (200 keys)") do
+    SMALL_TREE.derive.subtract_by_key!(SMALL_TREE_B)
+  end
+
+  x.report("subtract_by_key! (2k keys)") do
+    MEDIUM_TREE.derive.subtract_by_key!(MEDIUM_TREE_B)
+  end
+
+  x.compare!
+end
+
+# ---------------------------------------------------------------------------
+# Memory profiles (opt-in via --memory)
+# ---------------------------------------------------------------------------
+
+if MEMORY_PROFILE
+  BenchHelper.header("Memory — from_key_names (2k keys)")
+  MemoryProfiler.report { Siblings.from_key_names(MEDIUM_KEYS) }
+    .pretty_print(scale_bytes: true, detailed_report: false)
+
+  BenchHelper.header("Memory — from_nested_hash (2k keys)")
+  MemoryProfiler.report { Siblings.from_nested_hash(MEDIUM_HASH) }
+    .pretty_print(scale_bytes: true, detailed_report: false)
+end
+
+passed = true
+if SAVE_RESULTS
+  BenchHelper.save_results(construction_suite, "tree/construction")
+  BenchHelper.save_results(merge_suite, "tree/merge")
+  BenchHelper.save_results(traversal_suite, "tree/traversal")
+  BenchHelper.save_results(subtract_suite, "tree/subtract")
+end
+
+if COMPARE_RESULTS
+  passed = false unless BenchHelper.compare_baseline(construction_suite, "tree/construction")
+  passed = false unless BenchHelper.compare_baseline(merge_suite, "tree/merge")
+  passed = false unless BenchHelper.compare_baseline(traversal_suite, "tree/traversal")
+  passed = false unless BenchHelper.compare_baseline(subtract_suite, "tree/subtract")
+end
+
+exit(1) if COMPARE_RESULTS && !passed

data/config/locales/en.yml

@@ -51,6 +51,7 @@ en:
         missing: show missing translations, optionally match a pattern
         mv: rename/merge the keys in locale data that match the given pattern
         normalize: 'normalize translation data: sort and move to the right files'
+        prune: removes keys from non-base locales that are not present in base locale
         remove_unused: remove unused keys
         rm: remove the keys in locale data that match the given pattern
         translate_missing: translate missing keys with Google Translate or DeepL Pro, optionally match
@@ -121,6 +122,15 @@ en:
           Set OpenAI API key via OPENAI_API_KEY environment variable or translation.openai_api_key
           in config/i18n-tasks.yml. Get the key at https://openai.com/.
         no_results: OpenAI returned no results.
+    prune:
+      count:
+        one: "%{count} key to prune in %{locales}."
+        other: "%{count} keys to prune in %{locales}."
+        zero: No keys to prune.
+      pruned:
+        one: "%{count} key pruned from %{locales}."
+        other: "%{count} keys pruned from %{locales}."
+      title: Pruning keys in %{locales} that are not present in %{base_locale}
     remove_unused:
       confirm:
         one: "%{count} translation will be removed from %{locales}."

data/config/locales/ru.yml

@@ -50,6 +50,7 @@ ru:
         missing: показать недостающие переводы
         mv: переименовать / объединить ключи, которые соответствуют заданному шаблону
         normalize: нормализовать файлы переводов (сортировка и распределение)
+        prune: удаляет ключи из небазовых локалей, которые отсутствуют в базовой локали
         remove_unused: удалить неиспользуемые ключи
         rm: удалить ключи, которые соответствуют заданному шаблону
         translate_missing: перевести недостающие переводы с Google Translate / DeepL Pro
@@ -121,6 +122,19 @@ ru:
           Установить ключ API Яндекса с помощью переменной среды OPENAI_API_KEY или translation.openai_api_key
            в config / i18n-tasks.yml. Получите ключ по адресу https://openai.com/.
         no_results: Яндекс не дал результатов.
+    prune:
+      count:
+        few: "%{count} ключа для удаления в %{locales}."
+        many: "%{count} ключей для удаления в %{locales}."
+        one: "%{count} ключ удаления в %{locales}."
+        other: "%{count} ключей для удаления в %{locales}."
+        zero: Нет ключей для удаления.
+      pruned:
+        few: "%{count} ключа удалено из %{locales}."
+        many: "%{count} ключeй удалены из %{locales}."
+        one: "%{count} ключ удалён из %{locales}."
+        other: "%{count} ключeй удалены из %{locales}."
+      title: Обрезка ключей в %{locales}, которые не присутствуют в %{base_locale}
     remove_unused:
       confirm:
         few: Переводы (%{count}) будут удалены из %{locales}.

data/i18n-tasks.gemspec

@@ -45,7 +45,7 @@ Gem::Specification.new do |s|
   s.add_dependency "highline", ">= 3.0.0"
   s.add_dependency "i18n"
   s.add_dependency "parser", ">= 3.2.2.1"
-  s.add_dependency "prism"
+  s.add_dependency "prism", ">= 0.28"
   s.add_dependency "rails-i18n"
   s.add_dependency "rainbow", ">= 2.2.2", "< 4.0"
   s.add_dependency "ruby-progressbar", "~> 1.8", ">= 1.8.1"

data/lib/i18n/tasks/base_task.rb

@@ -19,6 +19,7 @@ require "i18n/tasks/string_interpolation"
 require "i18n/tasks/data"
 require "i18n/tasks/configuration"
 require "i18n/tasks/stats"
+require "i18n/tasks/prune"
 
 module I18n
   module Tasks
@@ -38,6 +39,7 @@ module I18n
       include Configuration
       include Data
       include Stats
+      include Prune
 
       def initialize(config_file: nil, **config)
         @config_override = config_file

data/lib/i18n/tasks/command/commands/check_prism.rb

@@ -42,10 +42,18 @@ module I18n::Tasks
 
             tree = i18n.used_in_source_tree
             keys = tree.nodes.select { |n| n.data[:occurrences].present? }
-            results[label] = keys.each_with_object({}) do |node, h|
-              full_key = node.full_key(root: false)
-              h[full_key] = node.data[:occurrences]
-            end
+            results[label] = {
+              keys: keys.each_with_object({}) do |node, h|
+                full_key = node.full_key(root: false)
+                h[full_key] = node.data[:occurrences]
+              end,
+              # Build a set of all keys including candidate keys
+              all_keys: keys.flat_map do |node|
+                full_key = node.full_key(root: false)
+                candidates = node.data[:occurrences].flat_map { |occ| occ.candidate_keys || [] }
+                [full_key] + candidates
+              end.uniq
+            }
           end
 
           # restore original config and caches
@@ -54,12 +62,29 @@ module I18n::Tasks
           i18n.instance_variable_set(:@search_config, nil)
           i18n.instance_variable_set(:@keys_used_in_source_tree, nil)
 
-          default_keys = results[:default].keys
-          prism_keys = results[:prism].keys
+          default_keys = results[:default][:keys].keys
+          prism_keys = results[:prism][:keys].keys
+
+          # Use all_keys (including candidate_keys) for comparison
+          default_all_keys = results[:default][:all_keys]
+          prism_all_keys = results[:prism][:all_keys]
+
+          # Calculate differences, but filter out keys that are candidate keys in the other parser
+          only_default_raw = (default_all_keys - prism_all_keys)
+          only_prism_raw = (prism_all_keys - default_all_keys)
+
+          # Filter out keys that exist as candidates in the other parser
+          only_default = only_default_raw.reject do |key|
+            # Check if this key is a candidate in prism results
+            results[:prism][:keys].any? { |_main_key, occs| occs.any? { |occ| occ.candidate_keys&.include?(key) } }
+          end.sort
 
-          only_default = (default_keys - prism_keys).sort
-          only_prism = (prism_keys - default_keys).sort
-          both = (default_keys & prism_keys).sort
+          only_prism = only_prism_raw.reject do |key|
+            # Check if this key is a candidate in default results
+            results[:default][:keys].any? { |_main_key, occs| occs.any? { |occ| occ.candidate_keys&.include?(key) } }
+          end.sort
+
+          both = (default_all_keys & prism_all_keys).sort
 
           File.open(report_path, "w") do |f|
             f.puts "# i18n-tasks check_prism report"
@@ -70,6 +95,8 @@ module I18n::Tasks
             f.puts "Summary"
             f.puts "- total keys (default parser): #{default_keys.size}"
             f.puts "- total keys (prism): #{prism_keys.size}"
+            f.puts "- total keys including candidates (default parser): #{default_all_keys.size}"
+            f.puts "- total keys including candidates (prism): #{prism_all_keys.size}"
             f.puts "- keys in both: #{both.size}"
             f.puts "- keys only in default parser: #{only_default.size}"
             f.puts "- keys only in prism: #{only_prism.size}"
@@ -79,11 +106,24 @@ module I18n::Tasks
               f.puts "## Keys found by the default parser but NOT by Prism (#{only_default.size})"
               only_default.each do |k|
                 f.puts "\n### #{k}"
-                results[:default][k].first(5).each do |occ|
+                # Find occurrences where this key appears (either as main key or candidate)
+                occs = results[:default][:keys][k] || []
+                if occs.empty?
+                  # This key might be a candidate key, find which main key has it
+                  results[:default][:keys].each do |main_key, main_occs|
+                    main_occs.each do |occ|
+                      if occ.candidate_keys&.include?(k)
+                        occs << occ
+                      end
+                    end
+                  end
+                end
+                occs.first(5).each do |occ|
                   src = (occ.raw_key || k).to_s
                   line = (occ.line || "").strip
                   highlighted = line.gsub(src) { |m| "`#{m}`" }
-                  f.puts "- #{occ.path}:#{occ.line_num} `#{src}` — #{highlighted}"
+                  candidate_info = occ.candidate_keys ? " (candidates: #{occ.candidate_keys.join(", ")})" : ""
+                  f.puts "- #{occ.path}:#{occ.line_num} `#{src}`#{candidate_info} — #{highlighted}"
                 end
               end
             end
@@ -92,21 +132,33 @@ module I18n::Tasks
               f.puts "## Keys found by Prism but NOT by the default parser (#{only_prism.size})"
               only_prism.each do |k|
                 f.puts "\n### #{k}"
-                results[:prism][k].each do |occ|
+                # Find occurrences where this key appears (either as main key or candidate)
+                occs = results[:prism][:keys][k] || []
+                if occs.empty?
+                  # This key might be a candidate key, find which main key has it
+                  results[:prism][:keys].each do |main_key, main_occs|
+                    main_occs.each do |occ|
+                      if occ.candidate_keys&.include?(k)
+                        occs << occ
+                      end
+                    end
+                  end
+                end
+                occs.each do |occ|
                   src = (occ.raw_key || k).to_s
                   line = (occ.line || "").strip
                   highlighted = line.gsub(src) { |m| "`#{m}`" }
-                  f.puts "- #{occ.path}:#{occ.line_num} `#{src}` — #{highlighted}"
+                  candidate_info = occ.candidate_keys ? " (candidates: #{occ.candidate_keys.join(", ")})" : ""
+                  f.puts "- #{occ.path}:#{occ.line_num} `#{src}`#{candidate_info} — #{highlighted}"
                 end
               end
             end
 
             f.puts "\n## Notes"
-            f.puts "- This report compares keys discovered by the project default parser and by Prism (rails mode)."
+            f.puts "- This report compares keys discovered by the project default parser and by Prism (#{chosen_prism_mode} mode)."
           end
 
           log_stderr "Wrote check_prism report: #{report_path}"
-          puts File.read(report_path)
         end
 
         private

data/lib/i18n/tasks/command/commands/prune.rb

@@ -0,0 +1,57 @@
+module I18n::Tasks
+  module Command
+    module Commands
+      module Prune
+        include ::I18n::Tasks::Command::Collection
+
+        arg :keep_order,
+          "-k",
+          "--keep-order",
+          t("i18n_tasks.cmd.args.desc.keep_order")
+
+        cmd :prune, desc: t("i18n_tasks.cmd.desc.prune"), args: %i[confirm keep_order]
+        def prune(opts = {})
+          diff_forest = i18n.prunable_keys(
+            base_locale: i18n.base_locale,
+            locales: i18n.locales - [base_locale]
+          )
+
+          print_info t("i18n_tasks.prune.title", locales: locales.join(", "), base_locale: base_locale)
+
+          if diff_forest.empty?
+            print_success(t("i18n_tasks.prune.count", count: 0))
+            return
+          end
+
+          count = diff_forest.root_key_values.size
+
+          terminal_report.show_tree(diff_forest)
+          print_error(t("i18n_tasks.prune.count", count:, locales: locales.join(", ")))
+
+          # The user should confirm before we proceed with the deletion unless the force option is set
+          unless opts[:confirm] || agree(t("i18n_tasks.common.continue_q"))
+            return
+          end
+          print_success(t("i18n_tasks.prune.pruned", count:, locales: locales.join(", ")))
+
+          i18n.data.config = i18n.data.config.merge(sort: false) if opts[:"keep-order"]
+          i18n.data.remove_by_key!(diff_forest)
+        end
+
+        private
+
+        def print_success(message)
+          log_stderr(Rainbow("✓ #{message}").green.bright)
+        end
+
+        def print_error(message)
+          log_stderr(Rainbow(message).red.bright)
+        end
+
+        def print_info(message)
+          log_stderr(message)
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/commands.rb

@@ -11,6 +11,7 @@ require "i18n/tasks/command/commands/data"
 require "i18n/tasks/command/commands/tree"
 require "i18n/tasks/command/commands/meta"
 require "i18n/tasks/command/commands/check_prism"
+require "i18n/tasks/command/commands/prune"
 require "i18n/tasks/command/commander"
 
 module I18n::Tasks
@@ -25,6 +26,7 @@ module I18n::Tasks
     include Command::Commands::Tree
     include Command::Commands::Meta
     include Command::Commands::CheckPrism
+    include Command::Commands::Prune
 
     require "highline/import"
   end

data/lib/i18n/tasks/data/adapter/json_adapter.rb

@@ -9,7 +9,7 @@ module I18n::Tasks
         class << self
           # @return [Hash] locale tree
           def parse(str, opts)
-            JSON.parse(str, parse_opts(opts))
+            JSON.parse(str, **parse_opts(opts))
           end
 
           # @return [String]

data/lib/i18n/tasks/data/file_formats.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "active_support/core_ext/file/atomic"
 
 module I18n
   module Tasks
@@ -55,7 +56,9 @@ module I18n
           return if File.file?(path) && content == read_file(path)
 
           ::FileUtils.mkpath(File.dirname(path))
-          ::File.write(path, content)
+          ::File.atomic_write(path) do |file|
+            file.write(content)
+          end
         end
 
         def normalized?(path, tree)

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

@@ -16,33 +16,23 @@ module I18n::Tasks
       def route(locale, forest, &block) # rubocop:disable Metrics/AbcSize
         return to_enum(:route, locale, forest) unless block
 
-        out = Hash.new { |hash, key| hash[key] = Set.new }
-        not_found = Set.new
-        forest.keys do |key, _node|
-          path = key_path(locale, key)
+        locale = locale.to_s
+        leaves_by_path = Hash.new { |hash, path| hash[path] = [] }
+        forest.keys do |key, node|
+          key_parts = node.walk_from_root.drop(1).map(&:key)
+          path = key_path(locale, key_parts)
           # infer from another locale
           unless path
-            inferred_from = (locales - [locale]).detect { |loc| path = key_path(loc, key) }
+            inferred_from = (locales - [locale]).detect { |loc| path = key_path(loc, key_parts) }
             path = LocalePathname.replace_locale(path, inferred_from, locale) if inferred_from
           end
-          key_with_locale = "#{locale}.#{key}"
-          if path
-            out[path] << key_with_locale
-          else
-            not_found << key_with_locale
-          end
-        end
-
-        if not_found.present?
           # fall back to pattern router
-          not_found_tree = forest.select_keys(root: true) { |key, _| not_found.include?(key) }
-          super(locale, not_found_tree) do |path, tree|
-            out[path] += tree.key_names(root: true)
-          end
+          path ||= pattern_path(locale, key)
+          leaves_by_path[path] << node
         end
 
-        out.each do |dest, keys|
-          block.yield dest, forest.select_keys(root: true) { |key, _| keys.include?(key) }
+        leaves_by_path.each do |dest, leaves|
+          block.yield dest, select_leaves(forest, leaves)
         end
       end
 
@@ -52,8 +42,9 @@ module I18n::Tasks
         adapter[base_locale]
       end
 
-      def key_path(locale, key)
-        adapter[locale]["#{locale}.#{key}"].try(:data).try(:[], :path)
+      # Looked up by key parts: splitting the dotted key would lose blank keys (e.g. `''`) and split keys containing a dot.
+      def key_path(locale, key_parts)
+        adapter[locale].dig(locale, *key_parts).try(:data).try(:[], :path)
       end
 
       attr_reader :adapter, :base_locale, :locales

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

@@ -32,24 +32,36 @@ module I18n::Tasks
         return to_enum(:route, locale, forest) unless block
 
         locale = locale.to_s
-        out = {}
-        forest.keys do |key, _node|
-          pattern, path = routes.detect { |route| route[0] =~ key }
-          if pattern
-            key_match = $~
-            path = format(path, locale: locale)
-            path.gsub!(/\\\d+/) { |m| key_match[m[1..].to_i] }
-            (out[path] ||= Set.new) << "#{locale}.#{key}"
-          else
-            fail CommandError, "Cannot route key #{key}. Routes are #{@routes_config.inspect}"
-          end
+        leaves_by_path = Hash.new { |hash, path| hash[path] = [] }
+        forest.keys do |key, node|
+          leaves_by_path[pattern_path(locale, key)] << node
         end
-        out.each do |dest, keys|
-          block.yield dest,
-            forest.select_keys(root: true) { |key, _| keys.include?(key) }
+        leaves_by_path.each do |dest, leaves|
+          block.yield dest, select_leaves(forest, leaves)
         end
       end
 
+      protected
+
+      def pattern_path(locale, key)
+        pattern, path = routes.detect { |route| route[0] =~ key }
+        fail CommandError, "Cannot route key #{key}. Routes are #{@routes_config.inspect}" unless pattern
+
+        key_match = $~
+        path = format(path, locale: locale)
+        path.gsub!(/\\\d+/) { |m| key_match[m[1..].to_i] }
+        path
+      end
+
+      # @return [Siblings] the subtree of forest holding these leaves, without walking the rest of the forest
+      def select_leaves(forest, leaves)
+        selected = Set.new
+        leaves.each do |leaf|
+          leaf.walk_to_root { |node| break unless selected.add?(node) }
+        end
+        forest.select_nodes { |node| selected.include?(node) }
+      end
+
       private
 
       def compile_routes(routes)

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

@@ -192,10 +192,10 @@ module I18n::Tasks::Data::Tree
 
     class << self
       # value can be a nested hash
-      def from_key_value(key, value)
-        Node.new(key: key.try(:to_s)).tap do |node|
+      def from_key_value(key, value, parent: nil)
+        Node.new(key: key.try(:to_s), parent: parent).tap do |node|
           if value.is_a?(Hash)
-            node.children = Siblings.from_nested_hash(value)
+            node.children = Siblings.from_nested_hash(value, parent: node)
           else
             node.value = value
           end

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

@@ -81,9 +81,17 @@ module I18n::Tasks::Data::Tree
 
     # @return [Node] by full key
     def get(full_key)
-      first_key, rest = split_key(full_key.to_s, 2)
+      dig(*split_key(full_key.to_s))
+    end
+
+    # @return [Node] by key parts, which may be blank or contain a dot
+    def dig(first_key, *rest)
       node = key_to_node[first_key]
-      node = node.children.try(:get, rest) if rest && node
+      rest.each do |key|
+        return nil unless node&.children
+
+        node = node.children.key_to_node[key]
+      end
       node
     end
 
@@ -301,7 +309,7 @@ module I18n::Tasks::Data::Tree
         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 }
+        opts[:nodes] = hash.map { |key, value| Node.from_key_value key, value, parent: opts[:parent] }
         Siblings.new(opts)
       end