Revamp the configuration internal state for defining provisioners

lib/vagrant/plugin/v2/manager.rb

@@ -91,6 +91,17 @@ module Vagrant
           end
         end
 
+        # This returns all the config classes for the various provisioners.
+        #
+        # @return [Registry]
+        def provisioner_configs
+          Registry.new.tap do |result|
+            @registered.each do |plugin|
+              result.merge!(plugin.components.configs[:provisioner])
+            end
+          end
+        end
+
         # This returns all registered provisioners.
         #
         # @return [Hash]

plugins/kernel_v2/config/vm.rb

@@ -142,11 +142,6 @@ module VagrantPlugins
                               :name => name))
           end
         end
-
-        # Each provisioner can validate itself
-        provisioners.each do |prov|
-          prov.validate(env, errors)
-        end
       end
     end
   end

plugins/kernel_v2/config/vm_provisioner.rb

@@ -4,51 +4,36 @@ module VagrantPlugins
   module Kernel_V2
     # Represents a single configured provisioner for a VM.
     class VagrantConfigProvisioner
-      attr_reader :shortcut
-      attr_reader :provisioner
+      # The name of the provisioner that should be registered
+      # as a plugin.
+      #
+      # @return [Symbol]
+      attr_reader :name
+
+      # The configuration associated with the provisioner, if there is any.
+      #
+      # @return [Object]
       attr_reader :config
 
-      def initialize(shortcut, options=nil, &block)
+      def initialize(name, options=nil, &block)
         @logger = Log4r::Logger.new("vagrant::config::vm::provisioner")
-        @logger.debug("Provisioner config: #{shortcut}")
-        @shortcut = shortcut
-        @provisioner = shortcut
+        @logger.debug("Provisioner defined: #{name}")
+
         @config = nil
+        @name   = name
 
-        # If the shorcut is a symbol, we look through the registered
-        # plugins to see if any define a provisioner we want.
-        if shortcut.is_a?(Symbol)
-          @provisioner = Vagrant.plugin("2").manager.provisioners[shortcut]
-        end
-
-        @logger.info("Provisioner class: #{provisioner}")
-        configure(options, &block) if @provisioner
-      end
-
-      # Configures the provisioner if it can (if it is valid).
-      def configure(options=nil, &block)
-        config_class = @provisioner.config_class
-        return if !config_class
-
-        @logger.debug("Configuring provisioner with: #{config_class}")
-        @config = config_class.new
-        @config.set_options(options) if options
-        block.call(@config) if block
-      end
-
-      def validate(env, errors)
-        if !provisioner
-          # If we don't have a provisioner then the whole thing is invalid.
-          errors.add(I18n.t("vagrant.config.vm.provisioner_not_found", :shortcut => shortcut))
+        # Attempt to find the configuration class for this provider
+        # if it exists and load the configuration.
+        config_class = Vagrant.plugin("2").manager.provisioner_configs[@name]
+        if !config_class
+          @logger.info("Provisioner config for '#{@name}' not found. Ignoring config.")
           return
         end
 
-        if !(provisioner <= Vagrant.plugin("2", :provisioner))
-          errors.add(I18n.t("vagrant.config.vm.provisioner_invalid_class", :shortcut => shortcut))
-        end
-
-        # Pass on validation to the provisioner config
-        config.validate(env, errors) if config
+        @config = config_class.new
+        @config.set_options(options) if options
+        block.call(@config) if block
+        @config.finalize!
       end
     end
   end