vagrant-docker-hosts-manager 0.2.0 → 0.4.0

data/lib/vagrant-docker-hosts-manager/command.rb

@@ -10,281 +10,278 @@ module VagrantDockerHostsManager
         json: false,
         dry:  false,
         lang: nil,
-        no_emoji: false
+        no_emoji: false,
+        yes: false,
+        all: false
       }
 
-      raw_argv = @argv.dup
-      help_topic = begin
-        i = raw_argv.index { |x| x =~ /\A(?:help|--help|-h)\z/ }
-        cand = (i && raw_argv[i + 1]) ? raw_argv[i + 1] : nil
-        (cand && cand !~ /\A-/) ? cand : nil
-      rescue
-        nil
-      end
+      help_topic = extract_help_topic(@argv)
 
       parser = OptionParser.new do |o|
         o.banner = "Usage: vagrant hosts <apply|remove|view|help|version> [options]"
         o.on("--json", "Machine-readable JSON output") { opts[:json] = true }
         o.on("--lang LANG", "Force language (en|fr)")  { |v| opts[:lang] = v }
         o.on("--no-emoji", "Disable emoji in CLI output") { opts[:no_emoji] = true }
-        o.on("-h", "--help", "Show help") { print_help(@env.ui); return 0 }
+        o.on("-y", "--yes", "Auto-confirm destructive operations") { opts[:yes] = true }
+        o.on("--all", "--prune", "remove: purge ALL managed blocks (every machine, incl. orphans)") { opts[:all] = true }
       end
 
       argv = parse_options(parser)
       return 0 unless argv
 
       action = argv.shift
-      env    = @env
 
-      Util::I18n.setup!(env, forced: opts[:lang])
+      Util::I18n.setup!(@env, forced: opts[:lang])
       Util::I18n.set_json_mode(opts[:json])
       ENV["VDHM_DRY_RUN"]  = "1" if opts[:dry]
       ENV["VDHM_NO_EMOJI"] = "1" if opts[:no_emoji]
 
+      dispatch(action, argv, opts, help_topic)
+    rescue StandardError => e
+      Util::Json.emit(action: "command", status: "error", error: e.message)
+      UiHelpers.error(@env.ui, "#{UiHelpers.e(:error, no_emoji: opts[:no_emoji])} #{e.message}") unless opts[:json]
+      1
+    end
+
+    private
+
+    def dispatch(action, argv, opts, help_topic)
       case action
-      when nil, "", "help", "--help", "-h"
-        topic = help_topic || argv.shift
-        print_help(@env.ui, topic: topic, no_emoji: opts[:no_emoji])
-        return 0
-      when "version"
-        if opts[:json]
-          Util::Json.emit(action: "version", status: "success", data: { version: VagrantDockerHostsManager::VERSION })
+      when nil, "", "help"
+        print_help(@env.ui, topic: help_topic || argv.shift, no_emoji: opts[:no_emoji])
+        0
+      when "version" then cmd_version(opts)
+      when "apply"   then cmd_apply(argv, opts)
+      when "remove"  then cmd_remove(argv, opts)
+      when "view"    then cmd_view(argv, opts)
+      else
+        print_help(@env.ui, no_emoji: opts[:no_emoji])
+        0
+      end
+    end
+
+    def extract_help_topic(raw_argv)
+      i    = raw_argv.index { |x| x =~ /\A(?:help|--help|-h)\z/ }
+      cand = (i && raw_argv[i + 1]) ? raw_argv[i + 1] : nil
+      (cand && cand !~ /\A-/) ? cand : nil
+    rescue StandardError
+      nil
+    end
+
+    def cmd_version(opts)
+      if opts[:json]
+        Util::Json.emit(action: "version", status: "success", data: { version: VagrantDockerHostsManager::VERSION })
+      else
+        emoji = UiHelpers.e(:version, no_emoji: opts[:no_emoji])
+        line  = ::I18n.t("vdhm.log.version_line",
+                         default: "vagrant-docker-hosts-manager version %{version}",
+                         version: VagrantDockerHostsManager::VERSION)
+        UiHelpers.say(@env.ui, "#{emoji} #{line}")
+      end
+      0
+    end
+
+    def cmd_apply(argv, opts)
+      begin
+        ip_for_apply, host_for_apply =
+          parse_strict_mapping_from_argv!(argv, @env.ui, opts[:no_emoji], json: opts[:json])
+      rescue ArgumentError => e
+        Util::Json.emit(action: "apply", status: "error", error: e.message) if opts[:json]
+        return 1
+      end
+
+      machine = require_target_vm("apply", argv, opts) or return 1
+
+      if ip_for_apply || host_for_apply
+        code = validate_apply_mapping(ip_for_apply, host_for_apply, opts)
+        return code if code
+      end
+
+      mid    = machine.id || "unknown"
+      hoster = Util::HostsFile.new({ machine: machine, ui: @env.ui }, owner_id: mid)
+
+      entries =
+        if ip_for_apply && host_for_apply
+          { host_for_apply => ip_for_apply }
         else
-          emoji = UiHelpers.e(:version, no_emoji: opts[:no_emoji])
-          line  = ::I18n.t("log.version_line",
-                           default: "vagrant-docker-hosts-manager version %{version}",
-                           version: VagrantDockerHostsManager::VERSION)
-          UiHelpers.say(@env.ui, "#{emoji} #{line}")
+          compute_entries(machine, machine.config.docker_hosts)
         end
+
+      if entries.empty?
+        say_info(::I18n.t("vdhm.messages.no_entries", default: "No hosts entries configured."), opts)
+        Util::Json.emit(action: "apply", status: "noop", data: { reason: "no entries" })
         return 0
       end
 
-      machine = nil
+      return 0 if opts[:dry] && Util::Json.emit(action: "apply", status: "dry-run", data: { entries: entries })
 
-      case action
-      when "apply"
-        begin
-          ip_for_apply, host_for_apply =
-            parse_strict_mapping_from_argv!(argv, @env.ui, opts[:no_emoji], json: opts[:json])
-        rescue ArgumentError => e
-          Util::Json.emit(action: "apply", status: "error", error: e.message) if opts[:json]
-          return 1
-        end
+      hoster.apply(entries)
+      Util::Json.emit(action: "apply", status: "success", data: { entries: entries })
+      0
+    end
 
-        with_target_vms(argv, single_target: true) { |m| machine = m }
-
-        unless machine
-          UiHelpers.error(
-            @env.ui,
-            "#{UiHelpers.e(:error, no_emoji: opts[:no_emoji])} " +
-              ::I18n.t(
-                "errors.no_machine",
-                default: "No target machine found. Run this inside a Vagrant project or pass a VM name."
-              )
-          )
-          Util::Json.emit(action: "apply", status: "error", error: "No target machine found") if opts[:json]
-          return 1
-        end
+    def validate_apply_mapping(ip, host, opts)
+      unless ip && host
+        emit_error(::I18n.t("vdhm.messages.missing_mapping",
+          default: "Provide both IP and FQDN (e.g. `vagrant hosts apply 1.2.3.4 example.test`)."), opts)
+        return 1
+      end
+      unless ipv4?(ip)
+        emit_error(::I18n.t("vdhm.messages.invalid_ip", default: "Invalid IPv4 address: %{ip}", ip: ip), opts)
+        return 1
+      end
+      unless fqdn?(host)
+        emit_error(::I18n.t("vdhm.messages.invalid_host", default: "Invalid host/FQDN: %{host}", host: host), opts)
+        return 1
+      end
+      nil
+    end
 
-        if ip_for_apply || host_for_apply
-          unless ip_for_apply && host_for_apply
-            UiHelpers.error(@env.ui, "#{UiHelpers.e(:error, no_emoji: opts[:no_emoji])} " +
-              ::I18n.t("messages.missing_mapping",
-                default: "Provide both IP and FQDN (e.g. `vagrant hosts apply 1.2.3.4 example.test`)."))
-            return 1
-          end
-          unless ipv4?(ip_for_apply)
-            UiHelpers.error(@env.ui, "#{UiHelpers.e(:error, no_emoji: opts[:no_emoji])} " +
-              ::I18n.t("messages.invalid_ip", default: "Invalid IPv4 address: %{ip}", ip: ip_for_apply))
-            return 1
-          end
-          unless fqdn?(host_for_apply)
-            UiHelpers.error(@env.ui, "#{UiHelpers.e(:error, no_emoji: opts[:no_emoji])} " +
-              ::I18n.t("messages.invalid_host", default: "Invalid host/FQDN: %{host}", host: host_for_apply))
-            return 1
-          end
-        end
+    def cmd_remove(argv, opts)
+      return remove_all_owners(opts) if opts[:all]
 
-        cfg    = machine.config.docker_hosts
-        mid    = machine.id || "unknown"
-        hoster = Util::HostsFile.new({ machine: machine, ui: @env.ui }, owner_id: mid)
+      remove_key = parse_remove_key_from_argv!(argv)
 
-        unless ENV["VDHM_DRY_RUN"] == "1" || hoster.elevated?
-          UiHelpers.error(@env.ui, "#{UiHelpers.e(:error, no_emoji: opts[:no_emoji])} " +
-            ::I18n.t("errors.not_admin",
-              default: "Administrator/root privileges required to modify hosts at %{path}.",
-              path: hoster.printable_path))
-          return 1
-        end
+      machine = require_target_vm("remove", argv, opts) or return 1
 
-        entries = compute_entries(machine, cfg)
-        entries[host_for_apply] = ip_for_apply if ip_for_apply && host_for_apply
+      if remove_key && !(ipv4?(remove_key) || fqdn?(remove_key))
+        emit_error(::I18n.t("vdhm.messages.invalid_key", default: "Invalid IP or FQDN: %{key}", key: remove_key), opts)
+        UiHelpers.error(@env.ui, "  " + ::I18n.t("vdhm.messages.remove_expected_format",
+          default: "Expected IPv4 (e.g. 172.28.100.2) or FQDN (e.g. example.test)."))
+        Util::Json.emit(action: "remove", status: "error", error: "invalid parameter format") if opts[:json]
+        return 1
+      end
 
-        if entries.empty?
-          UiHelpers.say(@env.ui, "#{UiHelpers.e(:info, no_emoji: opts[:no_emoji])} " +
-            ::I18n.t("messages.no_entries", default: "No hosts entries configured."))
-          Util::Json.emit(action: "apply", status: "noop", data: { reason: "no entries" })
-          return 0
-        end
+      mid    = machine.id || "unknown"
+      hoster = Util::HostsFile.new({ machine: machine, ui: @env.ui }, owner_id: mid)
 
-        return 0 if opts[:dry] and Util::Json.emit(action: "apply", status: "dry-run", data: { entries: entries })
+      return remove_filtered(hoster, remove_key, mid, opts) if remove_key
 
-        hoster.apply(entries)
-        Util::Json.emit(action: "apply", status: "success", data: { entries: entries })
-        return 0
+      remove_all(machine, hoster, mid, opts)
+    end
 
-      when "remove"
-        remove_key = parse_remove_key_from_argv!(argv)
-
-        with_target_vms(argv, single_target: true) { |m| machine = m }
-
-        unless machine
-          UiHelpers.error(
-            @env.ui,
-            "#{UiHelpers.e(:error, no_emoji: opts[:no_emoji])} " +
-              ::I18n.t(
-                "errors.no_machine",
-                default: "No target machine found. Run this inside a Vagrant project or pass a VM name."
-              )
-          )
-          Util::Json.emit(action: "remove", status: "error", error: "No target machine found") if opts[:json]
-          return 1
-        end
+    def remove_filtered(hoster, remove_key, mid, opts)
+      return 0 if opts[:dry] && Util::Json.emit(action: "remove", status: "dry-run",
+                                                data: { owner: mid, key: remove_key })
+
+      removed = if ipv4?(remove_key)
+                  hoster.remove_entries!(ips: [remove_key], domains: [])
+                else
+                  hoster.remove_entries!(ips: [], domains: [remove_key])
+                end
+      Util::Json.emit(action: "remove", status: "success", data: { removed: removed, mode: "filtered" })
+      0
+    end
 
-        if remove_key && !(ipv4?(remove_key) || fqdn?(remove_key))
-          UiHelpers.error(@env.ui, "#{UiHelpers.e(:error, no_emoji: opts[:no_emoji])} " +
-            ::I18n.t("messages.invalid_key",
-              default: "Invalid IP or FQDN: %{key}", key: remove_key))
-          UiHelpers.error(@env.ui, "  " + ::I18n.t("messages.remove_expected_format",
-              default: "Expected IPv4 (e.g. 172.28.100.2) or FQDN (e.g. example.test)."))
-          Util::Json.emit(action: "remove", status: "error",
-            error: "invalid parameter format") if opts[:json]
+    def remove_all(machine, hoster, mid, opts)
+      return 0 if opts[:dry] && Util::Json.emit(action: "remove", status: "dry-run", data: { owner: mid })
+
+      vm_label = (machine.name rescue nil) || mid
+      unless opts[:yes]
+        if opts[:json]
+          emit_error(::I18n.t("vdhm.errors.confirmation_required",
+            default: "Confirmation required: pass --yes to proceed in --json mode."), opts)
+          Util::Json.emit(action: "remove", status: "error", error: "confirmation required")
           return 1
         end
+        unless confirm_all_removal?(@env.ui, vm_label, no_emoji: opts[:no_emoji])
+          say_info(::I18n.t("vdhm.messages.remove_all_cancelled", default: "Cancelled. Nothing removed."), opts)
+          Util::Json.emit(action: "remove", status: "cancelled", data: { owner: mid })
+          return 0
+        end
+      end
 
-        mid    = machine.id || "unknown"
-        hoster = Util::HostsFile.new({ machine: machine, ui: @env.ui }, owner_id: mid)
+      removed_block = hoster.remove!
+      Util::Json.emit(action: "remove", status: "success", data: { removed: removed_block })
+      0
+    end
+
+    def remove_all_owners(opts)
+      hoster = Util::HostsFile.new({ ui: @env.ui }, owner_id: "any")
+      return 0 if opts[:dry] && Util::Json.emit(action: "remove", status: "dry-run", data: { mode: "all" })
 
-        unless ENV["VDHM_DRY_RUN"] == "1" || hoster.elevated?
-          UiHelpers.error(@env.ui, "#{UiHelpers.e(:error, no_emoji: opts[:no_emoji])} " +
-            ::I18n.t("errors.not_admin",
-              default: "Administrator/root privileges required to modify hosts at %{path}.",
-              path: hoster.printable_path))
+      unless opts[:yes]
+        if opts[:json]
+          emit_error(::I18n.t("vdhm.errors.confirmation_required",
+            default: "Confirmation required: pass --yes to proceed in --json mode."), opts)
+          Util::Json.emit(action: "remove", status: "error", error: "confirmation required")
           return 1
         end
-
-        if remove_key
-          return 0 if opts[:dry] && Util::Json.emit(action: "remove", status: "dry-run",
-                                                     data: { owner: mid, key: remove_key })
-
-          removed = if ipv4?(remove_key)
-                      hoster.remove_entries!(ips: [remove_key], domains: [])
-                    else
-                      hoster.remove_entries!(ips: [], domains: [remove_key])
-                    end
-          Util::Json.emit(action: "remove", status: "success",
-                          data: { removed: removed, mode: "filtered" })
+        unless confirm_prune?(@env.ui, no_emoji: opts[:no_emoji])
+          say_info(::I18n.t("vdhm.messages.remove_all_cancelled", default: "Cancelled. Nothing removed."), opts)
+          Util::Json.emit(action: "remove", status: "cancelled", data: { mode: "all" })
           return 0
         end
+      end
 
-        return 0 if opts[:dry] && Util::Json.emit(action: "remove", status: "dry-run", data: { owner: mid })
+      removed = hoster.remove_all_managed!
+      Util::Json.emit(action: "remove", status: "success", data: { removed: removed, mode: "all" })
+      0
+    end
 
-        vm_label = (machine.name rescue nil) || mid
-        unless confirm_all_removal?(@env.ui, vm_label, no_emoji: opts[:no_emoji])
-          UiHelpers.say(@env.ui, "#{UiHelpers.e(:info, no_emoji: opts[:no_emoji])} " +
-            ::I18n.t("messages.remove_all_cancelled", default: "Cancelled. Nothing removed."))
-          Util::Json.emit(action: "remove", status: "cancelled", data: { owner: mid })
-          return 0
-        end
+    def cmd_view(_argv, opts)
+      hoster      = Util::HostsFile.new({ ui: @env.ui }, owner_id: "any")
+      managed_map = hoster.entries_in_blocks(:all)
+      pairs       = collect_view_pairs({}, managed_map)
 
-        removed_block = hoster.remove!
-        Util::Json.emit(action: "remove", status: "success", data: { removed: removed_block })
+      if opts[:json]
+        Util::Json.emit(action: "view", status: "success",
+          data: { entries: pairs.map { |ip, fqdn| { ip: ip, host: fqdn } } })
         return 0
+      end
 
-      when "view"
-        hoster       = Util::HostsFile.new({ ui: @env.ui }, owner_id: "any")
-        managed_map  = hoster.entries_in_blocks(:all)
-        planned_map = {}
-
-        begin
-          vm_for_view = nil
-          with_target_vms(argv.dup, single_target: true) { |m| vm_for_view = m }
-          if vm_for_view
-            cfg = vm_for_view.config.docker_hosts
-            planned_map = compute_entries(vm_for_view, cfg)
-          end
-        rescue StandardError
-          planned_map = {}
-        end
+      if pairs.empty?
+        say_info(::I18n.t("vdhm.messages.no_entries", default: "No hosts entries configured."), opts)
+        return 0
+      end
 
-        pairs = []
-        seen  = {}
+      say_info(::I18n.t("vdhm.messages.view_managed_header", default: "Managed hosts entries:"), opts)
+      pad = pairs.map { |ip, _| ip.length }.max || 0
+      pairs.each { |ip, fqdn| UiHelpers.say(@env.ui, "  • #{ip.ljust(pad)} -> #{fqdn}") }
+      0
+    end
 
-        planned_map.each do |fqdn, ip|
-          next if fqdn.to_s.empty? || ip.to_s.empty?
-          key = "#{ip}\0#{fqdn}"
-          next if seen[key]
-          pairs << [ip.to_s, fqdn.to_s]
-          seen[key] = true
-        end
+    def collect_view_pairs(planned_map, managed_map)
+      pairs = []
+      seen  = {}
+      add = lambda do |ip, fqdn|
+        return if fqdn.to_s.empty? || ip.to_s.empty?
 
-        managed_map.each do |fqdn, ips|
-          next if fqdn.to_s.empty?
-          Array(ips).each do |ip|
-            next if ip.to_s.empty?
-            key = "#{ip}\0#{fqdn}"
-            next if seen[key]
-            pairs << [ip.to_s, fqdn.to_s]
-            seen[key] = true
-          end
-        end
+        key = "#{ip}\0#{fqdn}"
+        return if seen[key]
 
-        if opts[:json]
-          Util::Json.emit(
-            action: "view",
-            status: "success",
-            data: { entries: pairs.map { |ip, fqdn| { ip: ip, host: fqdn } } }
-          )
-          return 0
-        end
+        pairs << [ip.to_s, fqdn.to_s]
+        seen[key] = true
+      end
 
-        emoji_info = UiHelpers.e(:info, no_emoji: opts[:no_emoji])
+      planned_map.each { |fqdn, ip| add.call(ip, fqdn) }
+      managed_map.each { |fqdn, ips| Array(ips).each { |ip| add.call(ip, fqdn) } }
+      pairs
+    end
 
-        if pairs.empty?
-          UiHelpers.say(@env.ui, "#{emoji_info} " + ::I18n.t("messages.no_entries",
-            default: "No hosts entries configured."))
-          return 0
-        end
+    def require_target_vm(action, argv, opts)
+      machine = nil
+      with_target_vms(argv, single_target: true) { |m| machine = m }
+      return machine if machine
 
-        header =
-          if planned_map.any?
-            ::I18n.t("messages.view_header", default: "Planned hosts entries:")
-          else
-            ::I18n.t("messages.view_managed_header", default: "Managed hosts entries:")
-          end
-
-        UiHelpers.say(@env.ui, "#{emoji_info} #{header}")
-        pad = pairs.map { |ip, _| ip.length }.max || 0
-        pairs.each do |ip, fqdn|
-          UiHelpers.say(@env.ui, "  • #{ip.ljust(pad)} -> #{fqdn}")
-        end
-        return 0
+      emit_error(::I18n.t("vdhm.errors.no_machine",
+        default: "No target machine found. Run this inside a Vagrant project or pass a VM name."), opts)
+      Util::Json.emit(action: action, status: "error", error: "No target machine found") if opts[:json]
+      nil
+    end
 
-      else
-        print_help(@env.ui, no_emoji: opts[:no_emoji])
-        return 0
-      end
-    rescue => e
-      Util::Json.emit(action: "command", status: "error", error: e.message)
-      1
+    def emit_error(message, opts)
+      UiHelpers.error(@env.ui, "#{UiHelpers.e(:error, no_emoji: opts[:no_emoji])} #{message}")
     end
 
-    private
+    def say_info(message, opts)
+      UiHelpers.say(@env.ui, "#{UiHelpers.e(:info, no_emoji: opts[:no_emoji])} #{message}")
+    end
 
     def confirm_all_removal?(ui, vm_label, no_emoji:)
       prompt = ::I18n.t(
-        "messages.confirm_remove_all",
-        default: "This will remove ALL managed hosts entries for %{vm}. Continue? (yes/No)",
+        "vdhm.messages.confirm_remove_all",
+        default: "This will remove ALL managed hosts entries for %{vm}. Continue? (y/N)",
         vm: vm_label.to_s
       )
 
@@ -294,7 +291,28 @@ module VagrantDockerHostsManager
         $stdout.print(line)
         $stdout.flush
         answer = ($stdin.gets || "").to_s
-      rescue
+      rescue StandardError
+        answer = ""
+      ensure
+        $stdout.puts ""
+      end
+
+      %w[y yes].include?(answer.strip.downcase)
+    end
+
+    def confirm_prune?(ui, no_emoji:)
+      prompt = ::I18n.t(
+        "vdhm.messages.confirm_prune",
+        default: "This will remove ALL managed hosts blocks from EVERY machine (orphans included). Continue? (y/N)"
+      )
+
+      line = "#{UiHelpers.e(:question, no_emoji: no_emoji)} #{prompt} "
+
+      begin
+        $stdout.print(line)
+        $stdout.flush
+        answer = ($stdin.gets || "").to_s
+      rescue StandardError
         answer = ""
       ensure
         $stdout.puts ""
@@ -310,13 +328,13 @@ module VagrantDockerHostsManager
         cand_ip, cand_host = argv[0], argv[1]
 
         unless ipv4?(cand_ip)
-          msg = ::I18n.t("messages.invalid_ip", default: "Invalid IPv4 address: %{ip}", ip: cand_ip)
+          msg = ::I18n.t("vdhm.messages.invalid_ip", default: "Invalid IPv4 address: %{ip}", ip: cand_ip)
           UiHelpers.error(ui, "#{UiHelpers.e(:error, no_emoji: no_emoji)} #{msg}")
           raise ArgumentError, msg
         end
 
         unless fqdn?(cand_host)
-          msg = ::I18n.t("messages.invalid_host", default: "Invalid host/FQDN: %{host}", host: cand_host)
+          msg = ::I18n.t("vdhm.messages.invalid_host", default: "Invalid host/FQDN: %{host}", host: cand_host)
           UiHelpers.error(ui, "#{UiHelpers.e(:error, no_emoji: no_emoji)} #{msg}")
           raise ArgumentError, msg
         end
@@ -326,7 +344,7 @@ module VagrantDockerHostsManager
       end
 
       if ipv4?(argv[0])
-        msg = ::I18n.t("messages.missing_mapping",
+        msg = ::I18n.t("vdhm.messages.missing_mapping",
           default: "Provide both IP and FQDN (e.g. `vagrant hosts apply 1.2.3.4 example.test`).")
         UiHelpers.error(ui, "#{UiHelpers.e(:error, no_emoji: no_emoji)} #{msg}")
         raise ArgumentError, msg
@@ -347,17 +365,6 @@ module VagrantDockerHostsManager
       s.split(".").all? { |lab| lab =~ /\A[a-zA-Z0-9](?:[a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\z/ }
     end
 
-    def parse_mapping_from_argv!(argv)
-      return [nil, nil] if argv.length < 2
-      cand_ip, cand_host = argv[0], argv[1]
-      if ipv4?(cand_ip) && cand_host !~ /\A-/
-        argv.shift(2)
-        [cand_ip, cand_host]
-      else
-        [nil, nil]
-      end
-    end
-
     def parse_remove_key_from_argv!(argv)
       return nil if argv.empty?
       cand = argv[0]
@@ -391,47 +398,47 @@ module VagrantDockerHostsManager
       return print_topic_help(ui, topic.to_s.downcase.strip, no_emoji: no_emoji) if topic && !topic.to_s.strip.empty?
 
       emoji_info = UiHelpers.e(:info, no_emoji: no_emoji)
-      title = ::I18n.t("help.title",  default: "Vagrant Docker Hosts Manager")
+      title = ::I18n.t("vdhm.help.title", default: "Vagrant Docker Hosts Manager")
       UiHelpers.say(ui, "#{emoji_info} #{title}")
 
-      UiHelpers.say(ui, ::I18n.t("help.usage",
+      UiHelpers.say(ui, ::I18n.t("vdhm.help.usage",
         default: "Usage: vagrant hosts <apply|remove|view|help|version> [options]"))
       UiHelpers.say(ui, "")
 
-      UiHelpers.say(ui, ::I18n.t("help.commands_header", default: "Commands:"))
-      cmds = ::I18n.t("help.commands", default: {})
+      UiHelpers.say(ui, ::I18n.t("vdhm.help.commands_header", default: "Commands:"))
+      cmds = ::I18n.t("vdhm.help.commands", default: {})
       cmds = {} unless cmds.is_a?(Hash)
       cmds.each_value { |line| UiHelpers.say(ui, "  #{line}") }
 
       UiHelpers.say(ui, "")
-      UiHelpers.say(ui, ::I18n.t("help.options_header", default: "Options:"))
-      optsh = ::I18n.t("help.options", default: {})
+      UiHelpers.say(ui, ::I18n.t("vdhm.help.options_header", default: "Options:"))
+      optsh = ::I18n.t("vdhm.help.options", default: {})
       optsh = {} unless optsh.is_a?(Hash)
       optsh.each_value { |line| UiHelpers.say(ui, "  #{line}") }
 
-      topics = (::I18n.t("help.topic", default: {}).is_a?(Hash) ? ::I18n.t("help.topic").keys.map(&:to_s) : [])
+      topics = (::I18n.t("vdhm.help.topic", default: {}).is_a?(Hash) ? ::I18n.t("vdhm.help.topic").keys.map(&:to_s) : [])
       topics = %w[apply remove view version help] if topics.empty?
 
       UiHelpers.say(ui, "")
-      UiHelpers.say(ui, ::I18n.t("help.topics_header", default: "Help topics:"))
+      UiHelpers.say(ui, ::I18n.t("vdhm.help.topics_header", default: "Help topics:"))
       UiHelpers.say(ui, "  vagrant hosts help <#{topics.join('|')}>")
     end
 
     def print_topic_help(ui, topic, no_emoji: false)
-      base   = "help.topic.#{topic}"
+      base   = "vdhm.help.topic.#{topic}"
       wrench = UiHelpers.e(:info, no_emoji: no_emoji)
 
-      title      = ::I18n.t("#{base}.title",       default: topic)
-      usage      = ::I18n.t("#{base}.usage",       default: nil)
-      desc       = ::I18n.t("#{base}.description", default: nil)
-      opts_hash  = ::I18n.t("#{base}.options",     default: {})
-      examples   = ::I18n.t("#{base}.examples",    default: [])
-
-      t_head   = ::I18n.t("help.topic_header",    default: "Help: vagrant hosts %{topic}", topic: topic)
-      t_usage  = ::I18n.t("help.usage_label",     default: "Usage:")
-      t_desc   = ::I18n.t("help.description_label", default: "Description:")
-      t_opts   = ::I18n.t("help.options_label",   default: "Options:")
-      t_exs    = ::I18n.t("help.examples_label",  default: "Examples:")
+      title      = ::I18n.t("vdhm.#{base}.title",       default: topic)
+      usage      = ::I18n.t("vdhm.#{base}.usage",       default: nil)
+      desc       = ::I18n.t("vdhm.#{base}.description", default: nil)
+      opts_hash  = ::I18n.t("vdhm.#{base}.options",     default: {})
+      examples   = ::I18n.t("vdhm.#{base}.examples",    default: [])
+
+      t_head   = ::I18n.t("vdhm.help.topic_header",    default: "Help: vagrant hosts %{topic}", topic: topic)
+      t_usage  = ::I18n.t("vdhm.help.usage_label",     default: "Usage:")
+      t_desc   = ::I18n.t("vdhm.help.description_label", default: "Description:")
+      t_opts   = ::I18n.t("vdhm.help.options_label",   default: "Options:")
+      t_exs    = ::I18n.t("vdhm.help.examples_label",  default: "Examples:")
 
       UiHelpers.say(ui, "#{wrench} #{t_head}")