vagrant-docker-certificates-manager 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f64aa238bae8dbe7da5f4b4554bc04baa2d70c955384ff64811e03ef684c791
-  data.tar.gz: ac5625a4e633a4e487ff814307920171db797da2a87a7f384da04f616d91c7e8
+  metadata.gz: 7205874687ebbce5453b9267447c8a007d949416b370e67d141b4e633193ce1b
+  data.tar.gz: 5970d32848bbb46f63f4d3b1dd0c12823350937e69363dbd1c4e1d7e7cf1ab16
 SHA512:
-  metadata.gz: 4cb997ec0c8d99ed7f221a634b0a0ff0e88aab81516d496c4b541adde7a1e85a88a9ea4ed6c902fafa593a8be6357f5706113def410561cb2b8eb22461a25745
-  data.tar.gz: 638c3572ab9ffa1d6ce7a7c7c4605022c41f257ffc801b30ed7fc3ee7a4d30a118b7a8b1871cf27f93c7b24308f5aca6d0db49810431ba8074bc54de58b275be
+  metadata.gz: da2f09201144ccaa74456e248c84d3c89297be73764c7d7cd2cc5a5fda5547c08b03d1eb9099fdab2808bf7a51e392faab5496ed3033ef86a4e96c9121388e88
+  data.tar.gz: 8a8f01b14910172242e72b62bd9dd889fcc79f56e0449f2d48ccffd763c91f5dab7a887ca52b214efdd8038d976c7e0c9464d4069b95c03ecd226fa1f30ebefd

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.4.0](https://github.com/julienpoirou/vagrant-docker-certificates-manager/compare/v0.3.0...v0.4.0) (2026-07-03)
+
+
+### Fonctionnalités ✨
+
+* Improve plugin quality and publish RubyDoc ([278298b](https://github.com/julienpoirou/vagrant-docker-certificates-manager/commit/278298b614ac9e4b0797d806bed3e0015d7fdb1f))
+
+
+### Corrections 🐛
+
+* Resolve rubocop offenses and enable pages for RubyDoc deploy ([227c596](https://github.com/julienpoirou/vagrant-docker-certificates-manager/commit/227c5967c1480a2771413cf5738d2ac1f030d495))
+
 ## [0.3.0](https://github.com/julienpoirou/vagrant-docker-certificates-manager/compare/v0.2.0...v0.3.0) (2026-03-09)
 
 

data/lib/vagrant-docker-certificates-manager/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/lib/vagrant-docker-certificates-manager/actions/install.rb

@@ -24,6 +24,15 @@ module VagrantDockerCertificatesManager
         @app.call(env)
       end
 
+      # Installs a configured certificate into the current host trust store.
+      #
+      # The operation is idempotent: when the fingerprint is already tracked,
+      # the current machine adopts the existing registry entry instead of
+      # reinstalling the certificate.
+      #
+      # @param cfg [#cert_path, #cert_name] Vagrant certificate configuration.
+      # @param env [Hash, nil] Vagrant environment hash.
+      # @return [Hash] Normalized result with code, status, data, or error.
       def self.perform_install(cfg, env)
         unless File.file?(cfg.cert_path)
           return { code: 1, status: "error",
@@ -32,9 +41,11 @@ error: UiHelpers.t("errors.invalid_path", path: cfg.cert_path) }
 
         name = cfg.cert_name.to_s.strip.empty? ? Cert.default_name_from(cfg.cert_path) : cfg.cert_name
         fp   = Cert.sha1(cfg.cert_path)
+        mid  = env && env[:machine]&.id
+
         if Registry.all.key?(fp)
-          return { code: 1, status: "error",
-error: UiHelpers.t("errors.already_present", name: name) }
+          Registry.adopt(fp, mid) if mid
+          return { code: 0, status: "success", data: { os: OS.detect, cert: name, already: true } }
         end
 
         os = OS.detect
@@ -51,7 +62,8 @@ firefox: cfg.manage_firefox)
           "path"      => File.expand_path(cfg.cert_path),
           "name"      => name,
           "nickname"  => Cert.nickname_for(name),
-          "os"        => os.to_s
+          "os"        => os.to_s,
+          "owners"    => [mid].compact
         })
         { code: 0, status: "success", data: { os: os, cert: name } }
       end

data/lib/vagrant-docker-certificates-manager/actions/uninstall.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require_relative "../util/os"
 require_relative "../util/ui"
 require_relative "../util/cert"
+require_relative "../util/generator"
 require_relative "../util/registry"
 require_relative "../helpers"
 
@@ -21,22 +23,61 @@ module VagrantDockerCertificatesManager
                  result[:status] == "success" ? "uninstall.success" : "uninstall.fail",
                  name: cfg.cert_name)
         end
+        purge_generated(cfg, env)
         @app.call(env)
       end
 
-      def self.perform_uninstall(cfg, _env)
+      def purge_generated(cfg, env)
+        # Generated material is purged only through explicit env flags to avoid
+        # deleting a CA/server certificate that may be shared outside this action.
+        files = []
+        files += [Generator::CA_CERT, Generator::CA_KEY, Generator::CRL] if env_flag?("VDCM_PURGE_CA_ON_DESTROY")
+        files += [Generator::SRV_CRT, Generator::SRV_KEY]                if env_flag?("VDCM_PURGE_SERVER_ON_DESTROY")
+        return if files.empty?
+
+        dir = cfg.cert_dir
+        files.uniq.each do |name|
+          path = File.join(dir, name)
+          next unless File.exist?(path)
+
+          File.delete(path)
+          Ui.say(env, :info, "purge.removed", path: path)
+        rescue StandardError => e
+          Ui.say(env, :warn, "purge.failed", path: path, error: e.message)
+        end
+      end
+
+      def env_flag?(name)
+        ENV[name].to_s == "1"
+      end
+
+      # Removes a configured certificate when the current machine is the last owner.
+      #
+      # Shared certificates stay installed until every machine recorded in the
+      # registry has released ownership.
+      #
+      # @param cfg [#cert_path, #cert_name] Vagrant certificate configuration.
+      # @param env [Hash, nil] Vagrant environment hash.
+      # @return [Hash] Normalized result with code, status, data, or error.
+      def self.perform_uninstall(cfg, env)
         fp_entry = Registry.find_by_path(cfg.cert_path)
         unless fp_entry
           return({ code: 1, status: "error",
                    error: UiHelpers.t("errors.not_found_for_remove", path: cfg.cert_path) })
         end
         fp, rec = fp_entry
+        mid = env && env[:machine]&.id
+
+        if mid && Registry.release(fp, mid)
+          return({ code: 0, status: "success", data: { kept: true, cert: rec["name"] } })
+        end
+
         os = OS.detect
         ok = case os
              when :mac     then OS.mac_remove_by_fp(fp)
              when :linux   then OS.linux_uninstall_cert(rec["name"], nss: cfg.manage_nss_browsers,
                                                                      firefox: cfg.manage_firefox)
-             when :windows then OS.win_remove_by_fp(fp)
+             when :windows then OS.win_remove_by_fp(fp, disable_firefox: !Registry.others_for_os?(fp, "windows"))
              else return({ code: 2, status: "error", error: UiHelpers.t("errors.os_unsupported") })
              end
         Registry.untrack(fp) if ok

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

@@ -1,37 +1,86 @@
 # frozen_string_literal: true
 
 module VagrantDockerCertificatesManager
+  # Vagrant configuration for certificate generation, installation, and cleanup.
+  #
+  # @!attribute cert_path
+  #   @return [String] Path to the CA certificate installed into the trust store.
+  # @!attribute cert_name
+  #   @return [String] Friendly certificate name used in host trust stores.
+  # @!attribute install_on_up
+  #   @return [Boolean] Whether to install the certificate during `vagrant up`.
+  # @!attribute remove_on_destroy
+  #   @return [Boolean] Whether to remove the certificate during `vagrant destroy`.
+  # @!attribute manage_firefox
+  #   @return [Boolean] Whether Firefox stores should be managed where supported.
+  # @!attribute manage_nss_browsers
+  #   @return [Boolean] Whether NSS browser stores should be managed where supported.
+  # @!attribute generate_on_up
+  #   @return [Boolean] Whether local certificate material should be generated during `vagrant up`.
   class Config < Vagrant.plugin("2", :config)
     attr_accessor :cert_path, :cert_name, :install_on_up, :remove_on_destroy,
                   :manage_firefox, :manage_nss_browsers, :locale, :verbose,
-                  :container_name
+                  :container_name,
+                  :generate_on_up, :ca_cn, :ca_days, :server_domain, :crl_url
 
     def initialize
-      @cert_path            = "certs/rootca.cert.pem"
-      @cert_name            = "local.dev"
-      @install_on_up        = false
-      @remove_on_destroy    = false
-      @manage_firefox       = false
-      @manage_nss_browsers  = true
-      @locale               = "en"
-      @verbose              = false
-      @container_name       = nil
+      @cert_path            = UNSET_VALUE
+      @cert_name            = UNSET_VALUE
+      @install_on_up        = UNSET_VALUE
+      @remove_on_destroy    = UNSET_VALUE
+      @manage_firefox       = UNSET_VALUE
+      @manage_nss_browsers  = UNSET_VALUE
+      @locale               = UNSET_VALUE
+      @verbose              = UNSET_VALUE
+      @container_name       = UNSET_VALUE
+      @generate_on_up       = UNSET_VALUE
+      @ca_cn                = UNSET_VALUE
+      @ca_days              = UNSET_VALUE
+      @server_domain        = UNSET_VALUE
+      @crl_url              = UNSET_VALUE
     end
 
     def finalize!
+      @cert_path           = "certs/rootca.cert.pem" if @cert_path == UNSET_VALUE
+      @cert_name           = "local.dev"             if @cert_name == UNSET_VALUE
+      @install_on_up       = false                   if @install_on_up == UNSET_VALUE
+      @remove_on_destroy   = false                   if @remove_on_destroy == UNSET_VALUE
+      @manage_firefox      = false                   if @manage_firefox == UNSET_VALUE
+      @manage_nss_browsers = true                    if @manage_nss_browsers == UNSET_VALUE
+      @locale              = "en"                    if @locale == UNSET_VALUE
+      @verbose             = false                   if @verbose == UNSET_VALUE
+      @container_name      = nil                     if @container_name == UNSET_VALUE
+      @generate_on_up      = false                   if @generate_on_up == UNSET_VALUE
+      @ca_cn               = "local-ca"              if @ca_cn == UNSET_VALUE
+      @ca_days             = 3650                    if @ca_days == UNSET_VALUE
+      @server_domain       = nil                     if @server_domain == UNSET_VALUE
+      @crl_url             = nil                     if @crl_url == UNSET_VALUE
+
       @install_on_up       = !!@install_on_up
       @remove_on_destroy   = !!@remove_on_destroy
       @manage_firefox      = !!@manage_firefox
       @manage_nss_browsers = !!@manage_nss_browsers
       @verbose             = !!@verbose
+      @generate_on_up      = !!@generate_on_up
       @locale              = (@locale || "en").to_s
+      @ca_cn               = (@ca_cn || "local-ca").to_s
+      @ca_days             = @ca_days.to_i
     end
 
     def validate(_machine)
       errors = []
       errors << "cert_path must be provided" if @cert_path.to_s.strip.empty?
       errors << "cert_name must be provided" if @cert_name.to_s.strip.empty?
+      unless @locale.is_a?(String) && %w[en fr].include?(@locale.to_s[0, 2].downcase)
+        errors << "locale must be 'en' or 'fr'"
+      end
+      errors << "ca_days must be a positive integer" if @generate_on_up && @ca_days.to_i <= 0
       { "vagrant-docker-certificates-manager" => errors }
     end
+
+    def cert_dir
+      d = File.dirname(@cert_path.to_s)
+      d.empty? ? "certs" : d
+    end
   end
 end

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

@@ -31,7 +31,11 @@ module VagrantDockerCertificatesManager
       return if defined?(@i18n_setup) && @i18n_setup
       ::I18n.enforce_available_locales = false
       base  = File.expand_path("../../locales", __dir__)
-      ::I18n.load_path |= Dir[File.join(base, "*.yml")]
+      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["VDCM_LANG"] || ENV["LANG"] || "en")[0, 2] rescue "en").to_sym
       ::I18n.default_locale = SUPPORTED.include?(default) ? default : :en
@@ -98,8 +102,6 @@ module VagrantDockerCertificatesManager
       ENV["VDCM_DEBUG"].to_s == "1"
     end
 
-    # ── display ───────────────────────────────────────────────────────────────
-
     def level_to_emoji(level)
       case level
       when :success then :success
@@ -130,8 +132,6 @@ module VagrantDockerCertificatesManager
       say(env_or_ui, :info, nil, raw: "#{e(:bug)} #{msg}")
     end
 
-    # ── help ──────────────────────────────────────────────────────────────────
-
     def print_general_help(no_emoji: false, ui: nil)
       setup_i18n!
       lines = []
@@ -139,6 +139,10 @@ module VagrantDockerCertificatesManager
       lines << "  #{t('cli.usage')}"
       t_hash("help.commands").each_value { |line| lines << "  #{line}" }
 
+      emit_lines(lines, ui)
+    end
+
+    def emit_lines(lines, ui)
       if ui
         lines.each { |ln| ui.info(ln) }
       else
@@ -151,39 +155,53 @@ module VagrantDockerCertificatesManager
       topic = (topic || "").to_s.strip.downcase
       return print_general_help(no_emoji: no_emoji, ui: ui) if topic.empty?
 
-      base  = "help.topic.#{topic}"
-      title = t("#{base}.title",       default: nil)
-      usage = t("#{base}.usage",       default: nil)
-      desc  = t("#{base}.description", default: nil)
-      opts  = t_hash("#{base}.options")
-      exs   = ::I18n.t(ns_key("#{base}.examples"), default: [])
+      fields = topic_help_fields("help.topic.#{topic}")
+      return print_general_help(no_emoji: no_emoji, ui: ui) if topic_help_empty?(fields)
 
-      if title.nil? && usage.nil? && desc.nil? && opts.empty? && exs.empty?
-        return print_general_help(no_emoji: no_emoji, ui: ui)
-      end
+      emit_lines(build_topic_help_lines(topic, fields, no_emoji), ui)
+    end
 
+    def topic_help_fields(base)
+      {
+        title: t("#{base}.title",       default: nil),
+        usage: t("#{base}.usage",       default: nil),
+        desc:  t("#{base}.description", default: nil),
+        opts:  t_hash("#{base}.options"),
+        exs:   ::I18n.t(ns_key("#{base}.examples"), default: [])
+      }
+    end
+
+    def topic_help_empty?(fields)
+      fields[:title].nil? && fields[:usage].nil? && fields[:desc].nil? &&
+        fields[:opts].empty? && fields[:exs].empty?
+    end
+
+    def build_topic_help_lines(topic, fields, no_emoji)
       lines = []
-      lines << "#{e(:info, no_emoji: no_emoji)} #{title || t('help.topic_fallback_title', topic: topic)}"
+      lines << "#{e(:info, no_emoji: no_emoji)} #{fields[:title] || t('help.topic_fallback_title', topic: topic)}"
       lines << "  #{t('help.usage_label')}"
-      lines << "    #{usage || 'vagrant certs help'}"
-      if desc && !desc.strip.empty?
-        lines << "  #{t('help.description_label')}"
-        lines << "    #{desc}"
-      end
-      unless opts.empty?
-        lines << "  #{t('help.options_label')}"
-        opts.each_value { |line| lines << "    #{line}" }
+      lines << "    #{fields[:usage] || 'vagrant certs help'}"
+
+      desc = fields[:desc]
+      append_help_section(lines, t("help.description_label"), ["    #{desc}"]) if desc && !desc.strip.empty?
+      unless fields[:opts].empty?
+        append_help_section(lines, t("help.options_label"), fields[:opts].values.map do |l|
+          "    #{l}"
+        end)
       end
+
+      exs = fields[:exs]
       if exs.is_a?(Array) && !exs.empty?
-        lines << "  #{t('help.examples_label')}"
-        exs.each { |ex| lines << "    #{ex}" }
+        append_help_section(lines, t("help.examples_label"), exs.map do |ex|
+          "    #{ex}"
+        end)
       end
+      lines
+    end
 
-      if ui
-        lines.each { |ln| ui.info(ln) }
-      else
-        lines.each { |ln| puts ln }
-      end
+    def append_help_section(lines, label, body_lines)
+      lines << "  #{label}"
+      body_lines.each { |line| lines << line }
     end
   end
 end

data/lib/vagrant-docker-certificates-manager/util/cert.rb

@@ -31,5 +31,99 @@ module VagrantDockerCertificatesManager
     def nickname_for(name)
       "#{MARKER}:#{name}"
     end
+
+    def fingerprint_of(cert)
+      OpenSSL::Digest::SHA1.hexdigest(cert.to_der).upcase
+    end
+
+    # Generates a local development certificate authority.
+    #
+    # The generated CA is intended for local Docker/Vagrant workflows, not as a
+    # public browser-trusted certificate authority.
+    #
+    # @param cn [String] Common name for the CA certificate.
+    # @param days [Integer] Validity period in days.
+    # @param org [String] Organization attribute written to the subject.
+    # @param country [String] Country attribute written to the subject.
+    # @return [Array<OpenSSL::X509::Certificate, OpenSSL::PKey::RSA>] Generated certificate and private key.
+    def generate_ca(common_name:, days: 3650, org: "VDCM", country: "FR")
+      key  = OpenSSL::PKey::RSA.generate(2048)
+      cert = OpenSSL::X509::Certificate.new
+
+      cert.version    = 2
+      cert.serial     = 1
+      cert.subject    = OpenSSL::X509::Name.parse("/CN=#{common_name}/O=#{org}/C=#{country}")
+      cert.issuer     = cert.subject
+      cert.public_key = key.public_key
+      cert.not_before = Time.now
+      cert.not_after  = Time.now + (days * 24 * 60 * 60)
+
+      ef = OpenSSL::X509::ExtensionFactory.new(cert, cert)
+      cert.add_extension(ef.create_extension("basicConstraints",     "CA:TRUE",             true))
+      cert.add_extension(ef.create_extension("keyUsage",             "keyCertSign,cRLSign", true))
+      cert.add_extension(ef.create_extension("subjectKeyIdentifier", "hash"))
+      cert.sign(key, OpenSSL::Digest.new("SHA256"))
+
+      [cert, key]
+    end
+
+    def load_ca(cert_path, key_path)
+      [
+        OpenSSL::X509::Certificate.new(File.read(cert_path)),
+        OpenSSL::PKey::RSA.new(File.read(key_path))
+      ]
+    end
+
+    # Generates a server certificate signed by the supplied local CA.
+    #
+    # Modern clients validate the SAN extension; the CN is kept mainly for
+    # readability and compatibility with older tooling.
+    #
+    # @param ca_cert [OpenSSL::X509::Certificate] CA certificate used as issuer.
+    # @param ca_key [OpenSSL::PKey::RSA] CA private key used to sign the certificate.
+    # @param domain [String] DNS name written to CN and subjectAltName.
+    # @param days [Integer] Validity period in days.
+    # @param crl_url [String, nil] Optional CRL distribution point URL.
+    # @return [Array<OpenSSL::X509::Certificate, OpenSSL::PKey::RSA>] Generated certificate and private key.
+    def generate_server(ca_cert, ca_key, domain:, days: 825, crl_url: nil)
+      key  = OpenSSL::PKey::RSA.generate(2048)
+      cert = OpenSSL::X509::Certificate.new
+
+      cert.version    = 2
+      cert.serial     = 2
+      cert.subject    = OpenSSL::X509::Name.parse("/CN=#{domain}")
+      cert.issuer     = ca_cert.subject
+      cert.public_key = key.public_key
+      cert.not_before = Time.now
+      cert.not_after  = Time.now + (days * 24 * 60 * 60)
+
+      ef = OpenSSL::X509::ExtensionFactory.new(ca_cert, cert)
+      cert.add_extension(ef.create_extension("subjectAltName",   "DNS:#{domain}"))
+      cert.add_extension(ef.create_extension("basicConstraints", "CA:FALSE"))
+      cert.add_extension(ef.create_extension("keyUsage",         "digitalSignature,keyEncipherment", true))
+      cert.add_extension(ef.create_extension("extendedKeyUsage", "serverAuth"))
+      unless crl_url.to_s.strip.empty?
+        cert.add_extension(ef.create_extension("crlDistributionPoints", "URI:#{crl_url}"))
+      end
+      cert.sign(ca_key, OpenSSL::Digest.new("SHA256"))
+
+      [cert, key]
+    end
+
+    # Generates an empty certificate revocation list for the local CA.
+    #
+    # @param ca_cert [OpenSSL::X509::Certificate] CA certificate used as issuer.
+    # @param ca_key [OpenSSL::PKey::RSA] CA private key used to sign the CRL.
+    # @param days [Integer] Validity period in days.
+    # @return [OpenSSL::X509::CRL] Signed CRL.
+    def generate_crl(ca_cert, ca_key, days: 3650)
+      crl = OpenSSL::X509::CRL.new
+      crl.issuer      = ca_cert.subject
+      crl.version     = 1
+      crl.last_update = Time.now
+      crl.next_update = Time.now + (days * 24 * 60 * 60)
+      crl.sign(ca_key, OpenSSL::Digest.new("SHA256"))
+      crl
+    end
   end
 end

data/lib/vagrant-docker-certificates-manager/util/registry.rb

@@ -15,6 +15,12 @@ module VagrantDockerCertificatesManager
       FileUtils.mkdir_p(File.dirname(db_path))
     end
 
+    # Loads tracked certificates from the best-effort local registry.
+    #
+    # A corrupt or missing registry must not block Vagrant actions, because the
+    # OS trust store remains the source of truth.
+    #
+    # @return [Hash] Registry data keyed by certificate fingerprint.
     def load
       ensure_dir!
       return {} unless File.exist?(db_path)
@@ -28,6 +34,11 @@ module VagrantDockerCertificatesManager
       File.write(db_path, JSON.pretty_generate(data))
     end
 
+    # Tracks a certificate fingerprint and its ownership metadata.
+    #
+    # @param fp [String] Certificate fingerprint.
+    # @param attrs [Hash] Persisted metadata such as path, name, OS, and owners.
+    # @return [void]
     def track(fp, attrs)
       data = load
       data[fp] = attrs
@@ -41,6 +52,42 @@ module VagrantDockerCertificatesManager
       removed
     end
 
+    # Adds an owner to an already tracked certificate.
+    #
+    # @param fp [String] Certificate fingerprint.
+    # @param owner [String, #to_s] Vagrant machine id adopting the certificate.
+    # @return [Boolean] Whether the certificate was already tracked.
+    # rubocop:disable Naming/PredicateMethod -- boolean return kept for symmetry with #release
+    def adopt(fp, owner)
+      data = load
+      return false unless data[fp]
+      data[fp]["owners"] = Array(data[fp]["owners"]) | [owner.to_s]
+      save(data)
+      true
+    end
+    # rubocop:enable Naming/PredicateMethod
+
+    # Releases one owner from a tracked certificate.
+    #
+    # Keep the certificate installed while at least one Vagrant machine still
+    # owns it.
+    #
+    # @param fp [String] Certificate fingerprint.
+    # @param owner [String, #to_s] Vagrant machine id releasing the certificate.
+    # @return [Boolean] Whether other owners remain after the release.
+    # rubocop:disable Naming/PredicateMethod -- boolean return kept for symmetry with #adopt
+    def release(fp, owner)
+      data = load
+      rec  = data[fp]
+      return false unless rec
+      owners = Array(rec["owners"])
+      owners.delete(owner.to_s)
+      rec["owners"] = owners
+      save(data)
+      !owners.empty?
+    end
+    # rubocop:enable Naming/PredicateMethod
+
     def find_by_path(path)
       data = load
       data.find { |_fp, v| File.expand_path(v["path"]) == File.expand_path(path) }
@@ -49,5 +96,9 @@ module VagrantDockerCertificatesManager
     def all
       load
     end
+
+    def others_for_os?(fp, os)
+      load.any? { |k, v| k != fp && v["os"].to_s == os.to_s }
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-docker-certificates-manager
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Julien Poirou
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-09 00:00:00.000000000 Z
+date: 2026-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n