vagrant-config_builder 0.1.0

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright 2013 Adrien Thebo
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

data/README.markdown

@@ -0,0 +1,65 @@
+Vagrant Config Builder
+======================
+
+Configure and manage your Vagrant environments with data.
+
+Synopsis
+--------
+
+This plugin provides an interface to the Vagrant configuration constructs in a
+logic free manner. You can format your input data to fit your needs and use
+`vagrant-config_builder` to transform that into the needed Vagrant config.
+
+Example
+-------
+
+This example loads all yaml files in the config directory and generates a
+Vagrant config based on that information. File names are arbitrary and chosen
+for clarity.
+
+#### Directory structure
+
+    .
+    ├── config
+    │   ├── roles.yaml
+    │   └── vms.yaml
+    └── Vagrantfile
+
+#### Vagrantfile
+
+    require 'config_builder'
+    Vagrant.configure('2', &ConfigBuilder.load(
+      :yaml,
+      :yamldir,
+      File.expand_path('config', __DIR__)
+    ))
+
+#### config/roles.yaml
+
+    ---
+    roles:
+      bigvm:
+        provider:
+          type: virtualbox
+          customize: [[modifyvm, !ruby/sym id, '--memory', 1024]]
+
+#### config/vms.yaml
+
+    ---
+    vms:
+      -
+        name: db
+        private_networks: [ {ip: '10.20.1.2'} ]
+        box: centos-5-i386
+        roles: bigvm
+      -
+        name: web
+        private_networks: [ {ip: '10.20.1.3'} ]
+        box: centos-5-i386
+
+Installation
+------------
+
+Installation into the Vagrant internal gems:
+
+  * `vagrant plugin install vagrant-config_builder`

data/examples/roles.yaml

@@ -0,0 +1,29 @@
+---
+roles:
+  puppetmaster:
+    provider:
+      type: virtualbox
+      customize: [[modifyvm, !ruby/sym id, '--memory', 1024]]
+    provisioners:
+      -
+        type: shell
+        inline: 'echo "nameserver 8.8.8.8" > /etc/resolv.conf'
+      -
+        type: hosts
+      -
+        type: pe_bootstrap
+        role: !ruby/sym master
+        relocate_manifests: false
+        version: '2.6.0'
+  puppetagent:
+    provisioners:
+      -
+        type: shell
+        inline: 'echo "nameserver 8.8.8.8" > /etc/resolv.conf'
+      -
+        type: hosts
+      -
+        type: pe_bootstrap
+        role: !ruby/sym agent
+        version: '2.6.0'
+

data/examples/vms.yaml

@@ -0,0 +1,12 @@
+---
+vms:
+  -
+    name: master
+    private_networks: [ {auto_network: true} ]
+    box: centos-5-i386
+    roles: puppetmaster
+  -
+    name: agent
+    private_networks: [ {auto_network: true} ]
+    box: centos-5-i386
+    roles: puppetagent

data/lib/config_builder/action/load_extensions.rb

@@ -0,0 +1,14 @@
+module ConfigBuilder
+  module Action
+    class LoadExtensions
+      def initialize(app, env)
+        @app, @env = app, env
+      end
+
+      def call(hash)
+        hash[:env].hook(:config_builder_extension)
+        @app.call(hash)
+      end
+    end
+  end
+end

data/lib/config_builder/class_registry.rb

@@ -0,0 +1,58 @@
+require 'vagrant/errors'
+
+module ConfigBuilder
+
+  # This defines a registry for classes, and behaves as a factory for registered classes.
+  #
+  # @api private
+  class ClassRegistry
+
+    class UnknownEntryError < Vagrant::Errors::VagrantError; end
+
+    def initialize(name)
+      @name    = name
+      @klasses = {}
+    end
+
+    # Register a class with a given identifier
+    #
+    # @param identifier [Symbol]
+    # @param klass [Class]
+    #
+    # @return [void]
+    def register(identifier, klass)
+      @klasses[identifier] = klass
+    end
+
+    # Retrieve a class associated with the specified identifier
+    #
+    # @param identifier [Symbol]
+    #
+    # @return [Class]
+    def retrieve(identifier)
+      if (klass = @klasses[identifier])
+        klass
+      else
+        raise UnknownEntryError, "#{self.inspect} doesn't have an entry registered with key #{identifier.inspect}"
+      end
+    end
+
+    # Generate a class instance with the given hash
+    #
+    # @param hash [Hash] The identifier and options for the new object
+    # @option hash type [String] The identifier of the class to instantiate
+    #
+    # @return [Object] The generated object
+    def generate(hash)
+      identifier = hash.delete('type')
+
+      klass = retrieve(identifier)
+
+      klass.new_from_hash(hash)
+    end
+
+    def inspect
+      "<#{self.class}: (#{@name})>"
+    end
+  end
+end

data/lib/config_builder/filter/roles.rb

@@ -0,0 +1,71 @@
+class ConfigBuilder::Filter::Roles
+
+  def run(input)
+    strip_filter_data(input)
+
+    vms = @vms.map { |vm_hash| filter_vm(vm_hash) }
+
+    add_filtered_data(input, vms)
+
+    input
+  end
+
+  private
+
+  def strip_filter_data(input)
+    @roles = input.delete('roles')
+    @vms   = input.delete('vms')
+  end
+
+  def add_filtered_data(input, vms)
+    input['vms'] = vms
+  end
+
+  def filter_vm(vm_hash)
+    role_names = roles_for_vm(vm_hash.delete('roles'))
+
+    new_vm_hash = merge_role_definitions(role_names)
+    new_vm_hash.merge!(vm_hash)
+
+    new_vm_hash
+  end
+
+  # Generate a hash of all the merged roles. Roles specified later in the hash
+  # overwrite earlier roles.
+  #
+  # @param names [Hash]
+  #
+  # @return [Hash]
+  def merge_role_definitions(role_names)
+    vm_template = {}
+
+    role_names.each do |name|
+      role_definition = @roles[name]
+      vm_template.merge!(role_definition)
+    end
+
+    vm_template
+  end
+
+  # @return [Array]
+  def roles_for_vm(role_field)
+    case role_field
+    when Array
+      rval = role_field
+    when String
+      rval = [role_field]
+    when NilClass
+      rval = []
+    end
+
+    rval
+  end
+
+  def role_definition(name)
+    if (defn = @roles[name])
+      defn
+    else
+      raise "Couldn't find role named #{name.inspect} in roles #{@roles.keys.inspect}"
+    end
+  end
+end

data/lib/config_builder/filter.rb

@@ -0,0 +1,5 @@
+module ConfigBuilder
+  module Filter
+    require 'config_builder/filter/roles'
+  end
+end

data/lib/config_builder/filter_stack.rb

@@ -0,0 +1,31 @@
+require 'config_builder/filter'
+
+module ConfigBuilder
+  class FilterStack
+
+    def initialize
+      @filter_stack = []
+    end
+
+    # @param input [Hash]
+    #
+    # @return [Hash]
+    def filter(input)
+      set_filters(input.delete(:filters))
+
+      @filter_stack.inject(input) do |current_input, filter|
+        filter.run(current_input)
+      end
+    end
+
+    private
+
+    def set_filters(list)
+      if list.nil?
+        @filter_stack << ConfigBuilder::Filter::Roles.new
+      else
+        raise NotImplementedError, "Custom lists of filters not implemented."
+      end
+    end
+  end
+end

data/lib/config_builder/loader/yaml.rb

@@ -0,0 +1,32 @@
+require 'yaml'
+
+class ConfigBuilder::Loader::YAML
+
+  # Load configuration from all files in a given directory
+  #
+  # @param dir_path [String]
+  #
+  # @return [Hash]
+  def yamldir(dir_path)
+    glob_path = File.join(dir_path, '*.{yml,yaml}')
+
+    rv = {}
+    Dir.glob(glob_path).each do |file|
+      contents = ::YAML.load_file(file)
+      rv.merge!(contents)
+    end
+
+    rv
+  end
+
+  # Load configuration from a file
+  #
+  # @param file_path [String]
+  #
+  # @return [Hash]
+  def yamlfile(file_path)
+    ::YAML.load_file(file_path)
+  end
+
+  ConfigBuilder::Loader.register(:yaml, self)
+end

data/lib/config_builder/loader.rb

@@ -0,0 +1,22 @@
+require 'config_builder/class_registry'
+
+module ConfigBuilder
+  module Loader
+    @registry = ConfigBuilder::ClassRegistry.new(:loader)
+
+    def self.register(identifier, klass)
+      @registry.register(identifier, klass)
+    end
+
+    def self.retrieve(identifier)
+      @registry.retrieve(identifier)
+    end
+
+    def self.generate(identifier, method_name, method_value)
+      obj = retrieve(identifier).new
+      obj.send(method_name, method_value)
+    end
+
+    require 'config_builder/loader/yaml'
+  end
+end

data/lib/config_builder/model/base.rb

@@ -0,0 +1,86 @@
+# A ConfigBuilder model implements a logic-less interface to a component of
+# Vagrant.
+#
+# A model should implement the following methods:
+#
+# ## `self.new_from_hash`
+#
+# This method takes an arbitrarily nested data structure of basic data types
+# (Arrays, Hashes, Numerics, Strings, etc) and instantiates a new object
+# with attributes set based on that data structure.
+#
+# ## `#to_proc`
+#
+# This method takes the object attributes and generates a lambda that will
+# create a Vagrant config with the state specified by the attributes. The
+# lambda should have an arity of one and should be passed a `config` object.
+# The generated block will generate the Vagrant config that implements the
+# behavior specified by the object attributes.
+#
+# If the Model delegates certain configuration to other models, the generated
+# lambda should be able to evaluate lambdas from the delegated models.
+#
+# Implementing classes do not need to inherit from ConfigBuilder::Model::Base,
+# but it makes life easier.
+class ConfigBuilder::Model::Base
+
+  # Deserialize a hash into a configbuilder model
+  #
+  # @param attributes [Hash] The model attributes as represented in a hash.
+  # @return [Object < ConfigBuilder::Model]
+  def self.new_from_hash(attributes)
+    obj = new()
+    obj.attrs = attributes
+    obj
+  end
+
+  # @api private
+  def attrs=(config)
+    hash = config.inject({}) { |hash, (key, value)| hash[key.to_sym] = value; hash }
+
+    if @defaults
+      @attrs = @defaults.merge(hash)
+    else
+      @attrs = hash
+    end
+  end
+
+  # Generate a block based on configuration specified by the attributes
+  #
+  # @abstract
+  # @return [Proc]
+  def to_proc
+    raise NotImplementedError
+  end
+
+  # Generate a block based on the attribute configuration and call it with
+  # the given config.
+  #
+  # @param [Vagrant.plugin('2', :config)]
+  # @return [void]
+  def call(config)
+    to_proc.call(config)
+  end
+
+  # @param identifier [Symbol]
+  #
+  # @return [Object] The value of the model attribute specified by `identifier`
+  #
+  # @todo validate identifier
+  def attr(identifier)
+    @attrs[identifier]
+  end
+  private :attr
+
+  class << self
+
+    # @param identifier [Symbol]
+    def def_model_attribute(identifier)
+      model_attributes << identifier
+    end
+
+    def model_attributes
+      (@identifiers ||= [])
+    end
+  end
+end

data/lib/config_builder/model/network/forwarded_port.rb

@@ -0,0 +1,32 @@
+# Vagrant forwarded port model
+#
+# @see http://docs.vagrantup.com/v2/networking/forwarded_ports.html
+class ConfigBuilder::Model::Network::ForwardedPort < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] guest
+  #   @return [Fixnum] The guest port
+  def_model_attribute :guest
+
+  # @!attribute [rw] host
+  #   @return [Fixnum] The host port
+  def_model_attribute :host
+
+  # @!attribute [rw] auto_correct
+  #   @return [Boolean] Whether to automatically correct port collisions
+  def_model_attribute :auto_correct
+
+  def initialize
+    @defaults = {:auto_correct => false}
+  end
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.network(
+        :forwarded_port,
+        :guest        => attr(:guest),
+        :host         => attr(:host),
+        :auto_correct => attr(:auto_correct)
+      )
+    end
+  end
+end

data/lib/config_builder/model/network/private_network.rb

@@ -0,0 +1,15 @@
+# Vagrant private network
+#
+# @see http://docs.vagrantup.com/v2/networking/private_network.html
+class ConfigBuilder::Model::Network::PrivateNetwork < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] :ip
+  #   @return [String] The IP address to use for the private network interface
+  def_model_attribute :ip
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.network(:private_network, :ip => attr(:ip))
+    end
+  end
+end

data/lib/config_builder/model/provider/virtualbox.rb

@@ -0,0 +1,35 @@
+# @see http://docs.vagrantup.com/v2/virtualbox/configuration.html
+class ConfigBuilder::Model::Provider::Virtualbox < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] name
+  #   @return [String] The name of the created VM in the Virtualbox GUI
+  def_model_attribute :name
+
+  # @!attribute [rw] customize
+  #   @return [Array<String>] A list of customize arguments to use upon VM instantiation.
+  def_model_attribute :customize
+
+  # @!attribute [rw] gui
+  #   @return [Boolean] Whether the GUI should be launched when the VM is created
+  def_model_attribute :gui
+
+  def initialize
+    @defaults = {:customize => []}
+  end
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.provider 'virtualbox' do |vb_config|
+        vb_config.name = attr(:name) if attr(:name)
+
+        attr(:customize).each do |cmd|
+          vb_config.customize cmd
+        end
+
+        vb_config.gui = attr(:gui) if attr(:gui)
+      end
+    end
+  end
+
+  ConfigBuilder::Model::Provider.register('virtualbox', self)
+end

data/lib/config_builder/model/provisioner/puppet.rb

@@ -0,0 +1,23 @@
+# @see http://docs.vagrantup.com/v2/provisioning/puppet_apply.html
+class ConfigBuilder::Model::Provisioner::Puppet
+
+  # @!attribute [rw] manifests_path
+  #   @return [String] The path to the puppet manifests.
+  attr_accessor :manifests_path
+
+  # @!attribute [rw] manifest_file
+  #   @return [String] The name of the manifest to apply
+  attr_accessor :manifest_file
+
+  # @!attribute [rw] module_path
+  #   @return [String] A colon separated set of filesystem paths for Puppet
+  attr_accessor :module_path
+
+  # @!attribute [rw] facter
+  #   @return [Hash] A hash of values to use as facts
+  attr_accessor :facter
+
+  # @!attribute [rw] options
+  #   @return [String] An arbitrary set of arguments for the `puppet` command
+  attr_accessor :options
+end

data/lib/config_builder/model/provisioner/puppet_server.rb

@@ -0,0 +1,15 @@
+# @see http://docs.vagrantup.com/v2/provisioning/puppet_agent.html
+class ConfigBuilder::Model::Provisioner::PuppetServer
+
+  # @!attribute [rw] puppet_server
+  #   @return [String]
+  attr_accessor :puppet_server
+
+  # @!attribute [rw] node_name
+  #   @return [String]
+  attr_accessor :node_name
+
+  # @!attribute [rw] options
+  #   @return [String]
+  attr_accessor :options
+end

data/lib/config_builder/model/provisioner/shell.rb

@@ -0,0 +1,27 @@
+# @see http://docs.vagrantup.com/v2/provisioning/shell.html
+class ConfigBuilder::Model::Provisioner::Shell < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] inline
+  #   @return [String] The inline shell command to run
+  def_model_attribute :inline
+
+  # @!attribute [rw] path
+  #   @return [String] The path to the shell script to run
+  def_model_attribute :path
+
+  # @!attribute [rw] args
+  #   @return [String] A string acting as an argument vector to the command.
+  def_model_attribute :args
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.provision :shell do |shell_config|
+        shell_config.inline = attr(:inline) if attr(:inline)
+        shell_config.path   = attr(:path)   if attr(:path)
+        shell_config.args   = attr(:args)   if attr(:args)
+      end
+    end
+  end
+
+  ConfigBuilder::Model::Provisioner.register('shell', self)
+end

data/lib/config_builder/model/root.rb

@@ -0,0 +1,41 @@
+# Model the root level Vagrant config object
+#
+# @see http://docs.vagrantup.com/v2/vagrantfile/index.html
+class ConfigBuilder::Model::Root < ConfigBuilder::Model::Base
+
+  include ConfigBuilder::ModelDelegator
+
+  def_model_delegator :vagrant
+  def_model_delegator :ssh
+  def_model_delegator :vms
+
+
+  def initialize
+    @defaults = {:vms => [], :vagrant => {}}
+  end
+
+  def to_proc
+    Proc.new do |root_config|
+      eval_models(root_config)
+    end
+  end
+
+  private
+
+  def eval_vms(root_config)
+    attr(:vms).each do |hash|
+      v = ConfigBuilder::Model::VM.new_from_hash(hash)
+      v.call(root_config)
+    end
+  end
+
+  def eval_vagrant(root_config)
+    if attr(:vagrant).has_key? :host
+      root_config.vagrant.host = attr(:vagrant)[:host]
+    end
+  end
+
+  def eval_ssh(root_config)
+
+  end
+end

data/lib/config_builder/model/ssh.rb

@@ -0,0 +1,10 @@
+# @see http://docs.vagrantup.com/v2/vagrantfile/ssh_settings.html
+class ConfigBuilder::Model::SSH < ConfigBuilder::Model::Base
+  # @!attribute [rw] guest_port
+  # @!attribute [rw] keepalive
+  # @!attribute [rw] max_tries
+  # @!attribute [rw] timeout
+  # @!attribute [rw] forward_x11
+  # @!attribute [rw] forward_agent
+  # @!attribute [rw] shell
+end

data/lib/config_builder/model/synced_folder.rb

@@ -0,0 +1,43 @@
+# Vagrant shared folder model.
+#
+# @see http://docs.vagrantup.com/v2/synced-folders/index.html
+class ConfigBuilder::Model::SyncedFolder < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] host_path
+  #   @return [String] The host file path to mount on the guest
+  def_model_attribute :host_path
+
+  # @!attribute [rw] guest_path
+  #   @return [String] The guest file path to be used as the mount point
+  def_model_attribute :guest_path
+
+  # @!attribute [rw] extra
+  #   A set of arbitrary options to pass to the virtualbox mount command.
+  #   @return [String]
+  def_model_attribute :extra
+
+  # @!attribute [rw] disabled
+  #   @return [Boolean] If the mount point should be disabled.
+  def_model_attribute :disabled
+
+  # @!attribute [rw] nfs
+  #   @return [Boolean] If the mount point should use NFS
+  def_model_attribute :nfs
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.synced_folder(attr(:host_path), attr(:guest_path), folder_opts)
+    end
+  end
+
+  private
+
+  def folder_opts
+    h = {}
+    h[:extra]    = attr(:extra)    if attr(:extra)
+    h[:disabled] = attr(:disabled) if attr(:disabled)
+    h[:nfs]      = attr(:nfs)      if attr(:nfs)
+
+    h
+  end
+end

data/lib/config_builder/model/vm.rb

@@ -0,0 +1,130 @@
+# @see http://docs.vagrantup.com/v2/vagrantfile/machine_settings.html
+class ConfigBuilder::Model::VM < ConfigBuilder::Model::Base
+
+  include ConfigBuilder::ModelDelegator
+
+  # @!attribute [rw] provider
+  #   @return [Hash<Symbol, Object>] The provider configuration for
+  #     this VM
+  #   @example
+  #     >> vm.provider
+  #     => {
+  #           :type => 'virtualbox',
+  #           :name => 'tiny-tina',
+  #           :gui  => false,
+  #        }
+  def_model_delegator :provider
+
+  # @!attribute [rw] provisioners
+  #   @return [Array<Hash<Symbol, Object>>] A collection of provisioner
+  #     parameters in the order that they should be applied
+  #     of provisioner types, and a list of provisioner instances for each type
+  #   @example
+  #     >> vm.provisioners
+  #     => [
+  #           {:type => :shell, :path   => '/vagrant/bin/magic.sh'},
+  #           {:type => :shell, :inline => '/bin/echo hello world'},
+  #
+  #           {:type => :puppet, :manifest => 'foo.pp'},
+  #           {:type => :puppet, :manifest => 'bar.pp', :modulepath => '/vagrant/modules'},
+  #        ]
+  def_model_delegator :provisioners
+
+  # @!attribute [rw] forwarded_ports
+  #   @return [Array<Hash<Symbol, Object>>] A collection of port mappings
+  #   @example
+  #     >> vm.forwarded_ports
+  #     => [
+  #           {:guest => 80, :host  => 20080},
+  #           {:guest => 443, :host => 20443},
+  #        ]
+  def_model_delegator :forwarded_ports
+
+  # @!attribute [rw] private_networks
+  #   @return [Array<Hash<Symbol, Object>>] A collection of IP address network
+  #     settings.
+  #   @example
+  #     >> vm.private_networks
+  #     => [
+  #           {:ip => '10.20.4.1'},
+  #           {:ip => '192.168.100.5', :netmask => '255.255.255.128'},
+  #        ]
+  def_model_delegator :private_networks
+
+  # @!attribute [rw] synced_folders
+  #   @return [Array<Hash<Symbol, Object>>]
+  #   @example
+  #     >> vm.synced_folders
+  #     => [
+  #           {:host_path => 'manifests/', :guest_path => '/root/manifests', :disabled => false},
+  #           {:host_path => 'modules/', :guest_path => '/root/modules'},
+  #        ]
+  #
+  def_model_delegator :synced_folders
+
+  # @!attribute [rw] box
+  #   @return [String] The name of the Vagrant box to instantiate for this VM
+  def_model_attribute :box
+
+  # @!attribute [rw] name
+  #   @return [String] The name of the instantiated box in this environment
+  def_model_attribute :name
+
+  def initialize
+    @defaults = {
+      :provisioners     => [],
+      :forwarded_ports  => [],
+      :private_networks => [],
+      :synced_folders   => [],
+    }
+  end
+
+  def to_proc
+    Proc.new do |global_config|
+      global_config.vm.define(attr(:name)) do |config|
+        vm_config = config.vm
+
+        vm_config.box = attr(:box) if defined? attr(:box)
+
+        eval_models(vm_config)
+      end
+    end
+  end
+
+  private
+
+  def eval_provisioners(vm_config)
+    attr(:provisioners).each do |hash|
+      p = ConfigBuilder::Model::Provisioner.new_from_hash(hash)
+      p.call(vm_config)
+    end
+  end
+
+  def eval_provider(vm_config)
+    if attr(:provider)
+      p = ConfigBuilder::Model::Provider.new_from_hash(attr(:provider))
+      p.call(vm_config)
+    end
+  end
+
+  def eval_private_networks(vm_config)
+    attr(:private_networks).each do |hash|
+      n = ConfigBuilder::Model::Network::PrivateNetwork.new_from_hash(hash)
+      n.call(vm_config)
+    end
+  end
+
+  def eval_forwarded_ports(vm_config)
+    attr(:forwarded_ports).each do |hash|
+      f = ConfigBuilder::Model::Network::ForwardedPort.new_from_hash(hash)
+      f.call(vm_config)
+    end
+  end
+
+  def eval_synced_folders(vm_config)
+    attr(:synced_folders).each do |hash|
+      f = ConfigBuilder::Model::SyncedFolder.new_from_hash(hash)
+      f.call(vm_config)
+    end
+  end
+end

data/lib/config_builder/model.rb

@@ -0,0 +1,62 @@
+require 'vagrant/errors'
+require 'config_builder/class_registry'
+require 'config_builder/model_delegator'
+
+module ConfigBuilder
+
+  module Model
+
+    class UnknownAttributeError < Vagrant::Errors::VagrantError; end
+
+    require 'config_builder/model/base'
+
+    require 'config_builder/model/root'
+
+    require 'config_builder/model/ssh'
+    #require 'config_builder/model/host'
+
+    require 'config_builder/model/vm'
+    require 'config_builder/model/synced_folder'
+
+    def self.generate(hash)
+      ConfigBuilder::Model::Root.new_from_hash(hash)
+    end
+
+    module Network
+      require 'config_builder/model/network/forwarded_port'
+      require 'config_builder/model/network/private_network'
+    end
+
+    module Provider
+
+      @registry = ConfigBuilder::ClassRegistry.new(:provider)
+
+      def self.new_from_hash(hash)
+        @registry.generate(hash)
+      end
+
+      def self.register(name, klass)
+        @registry.register(name, klass)
+      end
+
+      require 'config_builder/model/provider/virtualbox'
+    end
+
+    module Provisioner
+
+      @registry = ConfigBuilder::ClassRegistry.new(:provisioner)
+
+      def self.new_from_hash(hash)
+        @registry.generate(hash)
+      end
+
+      def self.register(name, klass)
+        @registry.register(name, klass)
+      end
+
+      require 'config_builder/model/provisioner/shell'
+      require 'config_builder/model/provisioner/puppet'
+      require 'config_builder/model/provisioner/puppet_server'
+    end
+  end
+end

data/lib/config_builder/model_delegator.rb

@@ -0,0 +1,30 @@
+module ConfigBuilder
+  module ModelDelegator
+
+    def model_delegators
+      self.class.model_delegators
+    end
+
+    def eval_models(config)
+      model_delegators.each do |model|
+        meth = "eval_#{model}"
+        send(meth, config)
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def def_model_delegator(identifier)
+        def_model_attribute(identifier)
+        model_delegators << identifier
+      end
+
+      def model_delegators
+        (@models ||= [])
+      end
+    end
+  end
+end

data/lib/config_builder/plugin.rb

@@ -0,0 +1,15 @@
+require 'vagrant'
+
+require 'config_builder/action/load_extensions'
+
+module VagrantPlugins
+  module ConfigBuilder
+    class Plugin < Vagrant.plugin('2')
+      name "Generate Vagrant configuration from logic-less data sources"
+
+      action_hook('ConfigBuilder: load extensions', :environment_load) do |hook|
+        hook.prepend(::ConfigBuilder::Action::LoadExtensions)
+      end
+    end
+  end
+end

data/lib/config_builder/runner.rb

@@ -0,0 +1,25 @@
+require 'config_builder/loader'
+require 'config_builder/filter_stack'
+require 'config_builder/model'
+
+module ConfigBuilder
+  class Runner
+
+    def run(identifier, method, value)
+      data = ConfigBuilder::Loader.generate(identifier, method, value)
+      filtered_data = run_filters(data)
+      model = generate_model(filtered_data)
+    end
+
+    private
+
+    def run_filters(data)
+      stack = ConfigBuilder::FilterStack.new
+      stack.filter(data)
+    end
+
+    def generate_model(filtered_hash)
+      ConfigBuilder::Model.generate(filtered_hash)
+    end
+  end
+end

data/lib/config_builder/version.rb

@@ -0,0 +1,3 @@
+module ConfigBuilder
+  VERSION = '0.1.0'
+end

data/lib/config_builder.rb

@@ -0,0 +1,14 @@
+require 'vagrant'
+
+module ConfigBuilder
+  require 'config_builder/loader'
+  require 'config_builder/model'
+  require 'config_builder/runner'
+  require 'config_builder/plugin'
+  require 'config_builder/version'
+
+  def self.load(identifier, method, value)
+    runner = ConfigBuilder::Runner.new
+    runner.run(identifier, method, value)
+  end
+end

data/lib/vagrant-config_builder.rb

@@ -0,0 +1 @@
+require 'config_builder'

data/vagrant-config_builder.gemspec

@@ -0,0 +1,19 @@
+$LOAD_PATH << File.expand_path(File.join('..', 'lib'), __FILE__)
+require 'config_builder/version'
+
+Gem::Specification.new do |gem|
+  gem.name    = 'vagrant-config_builder'
+  gem.version = ConfigBuilder::VERSION
+
+  gem.summary     = 'Generate Vagrant configurations from arbitrary data'
+
+  gem.authors  = 'Adrien Thebo'
+  gem.email    = 'adrien@somethingsinistral.net'
+  gem.homepage = 'https://github.com/adrienthebo/vagrant-config_builder'
+
+  gem.has_rdoc = true
+  gem.license  = 'Apache 2.0'
+
+  gem.files        = %x{git ls-files -z}.split("\0")
+  gem.require_path = 'lib'
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-config_builder
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Adrien Thebo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-08 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: adrien@somethingsinistral.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.markdown
+- examples/roles.yaml
+- examples/vms.yaml
+- lib/config_builder.rb
+- lib/config_builder/action/load_extensions.rb
+- lib/config_builder/class_registry.rb
+- lib/config_builder/filter.rb
+- lib/config_builder/filter/roles.rb
+- lib/config_builder/filter_stack.rb
+- lib/config_builder/loader.rb
+- lib/config_builder/loader/yaml.rb
+- lib/config_builder/model.rb
+- lib/config_builder/model/base.rb
+- lib/config_builder/model/network/forwarded_port.rb
+- lib/config_builder/model/network/private_network.rb
+- lib/config_builder/model/provider/virtualbox.rb
+- lib/config_builder/model/provisioner/puppet.rb
+- lib/config_builder/model/provisioner/puppet_server.rb
+- lib/config_builder/model/provisioner/shell.rb
+- lib/config_builder/model/root.rb
+- lib/config_builder/model/ssh.rb
+- lib/config_builder/model/synced_folder.rb
+- lib/config_builder/model/vm.rb
+- lib/config_builder/model_delegator.rb
+- lib/config_builder/plugin.rb
+- lib/config_builder/runner.rb
+- lib/config_builder/version.rb
+- lib/vagrant-config_builder.rb
+- vagrant-config_builder.gemspec
+homepage: https://github.com/adrienthebo/vagrant-config_builder
+licenses:
+- Apache 2.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Generate Vagrant configurations from arbitrary data
+test_files: []
+has_rdoc: true