vagrant-docker-hosts-manager 0.2.0 → 0.4.0

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

@@ -1,29 +1,49 @@
 # frozen_string_literal: true
 
 module VagrantDockerHostsManager
+  # Vagrant configuration for managed host entries.
+  #
+  # @!attribute domains
+  #   @return [Hash{String=>String}] Mapping of domain names to IP addresses.
+  # @!attribute domain
+  #   @return [String, nil] Single domain to resolve from `ip` or `container_name`.
+  # @!attribute container_name
+  #   @return [String, nil] Docker container used for automatic IP discovery.
+  # @!attribute ip
+  #   @return [String, nil] Static IPv4 address for `domain`.
+  # @!attribute locale
+  #   @return [String, nil] Optional locale code.
   class Config < Vagrant.plugin("2", :config)
     attr_accessor :domains
-
     attr_accessor :domain
-
     attr_accessor :container_name
-
     attr_accessor :ip
-
+    attr_accessor :locale
     attr_accessor :verbose
 
     def initialize
-      @domains        = {}
-      @domain         = nil
-      @container_name = nil
-      @ip             = nil
-      @verbose        = false
+      @domains        = UNSET_VALUE
+      @domain         = UNSET_VALUE
+      @container_name = UNSET_VALUE
+      @ip             = UNSET_VALUE
+      @locale         = UNSET_VALUE
+      @verbose        = UNSET_VALUE
     end
 
-    def finalize!; end
+    def finalize!
+      @domains        = {}    if @domains == UNSET_VALUE
+      @domain         = nil   if @domain == UNSET_VALUE
+      @container_name = nil   if @container_name == UNSET_VALUE
+      @ip             = nil   if @ip == UNSET_VALUE
+      @locale         = nil   if @locale == UNSET_VALUE
+      @verbose        = false if @verbose == UNSET_VALUE
+    end
 
     def validate(_machine)
       errors = []
+
+      return { "vagrant-docker-hosts-manager" => errors } unless configured?
+
       if (@domains.nil? || @domains.empty?) && (@domain.nil? || @domain.strip.empty?)
         errors << "You must configure at least one domain: " \
                   "`config.docker_hosts.domain = \"example.test\"` or set " \
@@ -38,7 +58,22 @@ module VagrantDockerHostsManager
         errors << "`ip` must be IPv4 like 172.28.0.10"
       end
 
+      if @locale && !%w[en fr].include?(@locale.to_s[0, 2].downcase)
+        errors << "`locale` must be 'en' or 'fr'."
+      end
+
       { "vagrant-docker-hosts-manager" => errors }
     end
+
+    private
+
+    def configured?
+      (@domains.is_a?(Hash) && !@domains.empty?) ||
+        present?(@domain) || present?(@container_name) || present?(@ip)
+    end
+
+    def present?(value)
+      !value.nil? && !value.to_s.strip.empty?
+    end
   end
 end

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

@@ -4,6 +4,13 @@ require "i18n"
 
 module VagrantDockerHostsManager
   module UiHelpers
+    class MissingTranslationError < StandardError; end
+    class UnsupportedLocaleError   < StandardError; end
+
+    SUPPORTED      = [:en, :fr].freeze
+    OUR_NAMESPACES = %w[messages. errors. log. help.].freeze
+    NS             = "vdhm"
+
     EMOJI = {
       success:  "✅",
       info:     "🔍",
@@ -18,21 +25,98 @@ module VagrantDockerHostsManager
 
     module_function
 
+    def setup_i18n!
+      return if defined?(@i18n_setup) && @i18n_setup
+
+      ::I18n.enforce_available_locales = false
+
+      base  = File.expand_path("../../locales", __dir__)
+      paths = Dir[File.join(base, "*.yml")]
+      if paths.empty? && File.directory?(base)
+        paths = Dir.children(base).grep(/\.ya?ml\z/).map { |file| File.join(base, file) }
+      end
+      ::I18n.load_path |= paths
+      ::I18n.available_locales = SUPPORTED
+
+      default = ((ENV["VDHM_LANG"] || ENV["LANG"] || "en")[0, 2] rescue "en").to_sym
+      ::I18n.default_locale = SUPPORTED.include?(default) ? default : :en
+
+      ::I18n.backend.load_translations
+      @i18n_setup = true
+    end
+
+    def set_locale!(lang)
+      setup_i18n!
+      sym = lang.to_s[0, 2].downcase.to_sym
+      unless SUPPORTED.include?(sym)
+        raise UnsupportedLocaleError,
+              "#{EMOJI[:error]} Unsupported language: #{sym}. Available: #{SUPPORTED.join(", ")}"
+      end
+      ::I18n.locale = sym
+      ::I18n.backend.load_translations
+    end
+
+    def setup_locale_from_config!(cfg)
+      lang = (cfg.respond_to?(:locale) ? cfg.locale : nil) || ENV["VDHM_LANG"]
+      return unless lang
+      set_locale!(lang)
+    rescue UnsupportedLocaleError
+      set_locale!("en")
+    end
+
+    def namespaced(key)
+      k = key.to_s
+      k.start_with?("#{NS}.") ? k : "#{NS}.#{k}"
+    end
+
+    def t(key, **opts)
+      setup_i18n!
+      ::I18n.t(namespaced(key), **opts)
+    end
+
+    def t!(key, **opts)
+      setup_i18n!
+      nk = namespaced(key)
+      if our_key?(key.to_s) && !::I18n.exists?(nk, ::I18n.locale)
+        raise MissingTranslationError, "#{EMOJI[:error]} [#{::I18n.locale}] Missing translation for key: #{nk}"
+      end
+      ::I18n.t(nk, **opts)
+    end
+
+    def t_hash(key)
+      setup_i18n!
+      v = ::I18n.t(namespaced(key), default: {})
+      v.is_a?(Hash) ? v : {}
+    end
+
+    def exists?(key)
+      ::I18n.exists?(key, ::I18n.locale)
+    end
+
+    def our_key?(k)
+      OUR_NAMESPACES.any? { |ns| k.start_with?(ns) }
+    end
+
     def e(key, no_emoji: false)
       return "" if no_emoji || ENV["VDHM_NO_EMOJI"] == "1"
       EMOJI[key] || ""
     end
 
-    def debug_enabled?
-      ENV["VDHM_DEBUG"].to_s == "1"
+    def say(ui, msg)
+      ui&.info(msg) || puts(msg)
+    end
+
+    def warn(ui, msg)
+      ui&.warn(msg) || puts(msg)
     end
 
-    def t(key, **opts)  = ::I18n.t(key, **opts)
-    def exists?(key)    = ::I18n.exists?(key, ::I18n.locale)
+    def error(ui, msg)
+      ui&.error(msg) || warn(ui, msg)
+    end
 
-    def say(ui, msg)    = (ui&.info(msg)  || puts(msg))
-    def warn(ui, msg)   = (ui&.warn(msg)  || puts(msg))
-    def error(ui, msg)  = (ui&.error(msg) || warn(ui, msg))
+    def debug_enabled?
+      ENV["VDHM_DEBUG"].to_s == "1"
+    end
 
     def debug(ui, msg)
       return unless debug_enabled?

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

@@ -11,6 +11,8 @@ require_relative "util/hosts_file"
 require_relative "util/docker"
 require_relative "util/json"
 require_relative "util/i18n"
+require_relative "actions/apply"
+require_relative "actions/cleanup"
 
 begin
   I18n.enforce_available_locales = false
@@ -39,7 +41,6 @@ module VagrantDockerHostsManager
 
     [:machine_action_up, :machine_action_provision, :machine_action_reload].each do |hook_name|
       action_hook(:vdhm_apply, hook_name) do |hook|
-        hook.after(Vagrant::Action::Builtin::Provision, Action::Apply)
         hook.append(Action::Apply)
       end
     end
@@ -48,95 +49,4 @@ module VagrantDockerHostsManager
       hook.prepend(Action::Cleanup)
     end
   end
-
-  module Action
-    class Apply
-      def initialize(app, env) = (@app = app)
-
-      def call(env)
-        Util::I18n.setup!(env)
-        cfg    = env[:machine].config.docker_hosts
-        mid    = env[:machine].id || "unknown"
-        dry    = Util::I18n.env_flag("VDHM_DRY_RUN")
-        ui     = env[:ui]
-        hoster = Util::HostsFile.new(env, owner_id: mid)
-
-        entries = compute_entries(env, cfg, ui)
-        if entries.empty?
-          ui.info(::I18n.t("messages.no_entries"))
-          return @app.call(env)
-        end
-
-        if dry
-          Util::Json.emit(action: "apply", status: "dry-run", data: { owner: mid, entries: entries })
-          return @app.call(env)
-        end
-
-        hoster.apply(entries)
-        Util::Json.emit(action: "apply", status: "success", data: { owner: mid, entries: entries })
-      rescue => e
-        Util::Json.emit(action: "apply", status: "error", error: e.message, backtrace: e.backtrace&.first(3))
-        ui&.error("VDHM: #{e.message}") || puts("VDHM: #{e.message}")
-      ensure
-        @app.call(env)
-      end
-
-      private
-
-      def compute_entries(env, cfg, ui)
-        entries = {}
-
-        cfg.domains.each do |domain, ip|
-          next if domain.to_s.strip.empty?
-          if ip.nil? || ip.to_s.strip.empty?
-            ui&.warn(::I18n.t("messages.missing_ip_for", domain: domain))
-            next
-          end
-          entries[domain] = ip
-        end
-
-        if cfg.domain && !cfg.domain.strip.empty?
-          ip = cfg.ip || begin
-            if cfg.container_name && !cfg.container_name.strip.empty?
-              Util::Docker.ip_for_container(cfg.container_name)
-            end
-          end
-          if ip && !ip.strip.empty?
-            ui&.info(::I18n.t("messages.detected_ip", domain: cfg.domain, ip: ip))
-            entries[cfg.domain] = ip
-          else
-            ui&.warn(::I18n.t("messages.no_ip_found", domain: cfg.domain, container: cfg.container_name))
-          end
-        end
-
-        entries
-      end
-    end
-
-    class Cleanup
-      def initialize(app, env) = (@app = app)
-
-      def call(env)
-        Util::I18n.setup!(env)
-        mid    = env[:machine].id || "unknown"
-        dry    = Util::I18n.env_flag("VDHM_DRY_RUN")
-        ui     = env[:ui]
-        hoster = Util::HostsFile.new(env, owner_id: mid)
-
-        if dry
-          Util::Json.emit(action: "cleanup", status: "dry-run", data: { owner: mid })
-          return @app.call(env)
-        end
-
-        removed = hoster.remove!
-        Util::Json.emit(action: "cleanup", status: "success", data: { owner: mid, removed: removed })
-        ui.info(::I18n.t("messages.cleaned"))
-      rescue => e
-        Util::Json.emit(action: "cleanup", status: "error", error: e.message)
-        ui.error("VDHM: #{e.message}")
-      ensure
-        @app.call(env)
-      end
-    end
-  end
 end

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

@@ -1,29 +1,28 @@
 # frozen_string_literal: true
 
 require "open3"
+require_relative "verbose"
 
 module VagrantDockerHostsManager
   module Util
     module Docker
       module_function
 
+      # Resolves the first IPv4 address exposed by Docker inspect for a container.
+      #
+      # @param name [String, #to_s] Docker container name or id.
+      # @return [String, nil] First IPv4 address, or nil when Docker cannot resolve it.
       def ip_for_container(name)
         return nil if name.to_s.strip.empty?
-        cmd = %(docker inspect -f "{{range .NetworkSettings.Networks}}{{.IPAddress}} {{end}}" #{shell_escape(name)})
-        out, _err, status = Open3.capture3(cmd)
+
+        fmt = "{{range .NetworkSettings.Networks}}{{.IPAddress}} {{end}}"
+        Verbose.log("docker", "inspect", "-f", fmt, name.to_s)
+        out, _err, status = Open3.capture3("docker", "inspect", "-f", fmt, name.to_s)
         return nil unless status.success?
         out.split(/\s+/).find { |ip| ip =~ /\A\d{1,3}(\.\d{1,3}){3}\z/ }
-      rescue
+      rescue StandardError
         nil
       end
-
-      def shell_escape(str)
-        if Gem.win_platform?
-          %("#{str.gsub('"', '\"')}")
-        else
-          %('#{str.gsub("'", "'\\\\''")}')
-        end
-      end
     end
   end
 end