jamie 0.1.0.alpha1 → 0.1.0.alpha2

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.3

data/.yardopts

@@ -0,0 +1,3 @@
+--readme README.md
+--markup markdown
+--markup-provider maruku

data/Gemfile

@@ -1,3 +1,8 @@
 source 'https://rubygems.org'
 
 gemspec
+
+group :test do
+  gem 'rake', '~> 0.9'
+  gem 'pry'
+end

data/Rakefile

@@ -1 +1,21 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'cane/rake_task'
+require 'tailor/rake_task'
+
+desc "Run cane to check quality metrics"
+Cane::RakeTask.new do |cane|
+  cane.abc_exclude = %w(
+    Jamie::RakeTasks#define
+    Jamie::Vagrant.define_vagrant_vm
+  )
+  cane.style_exclude = %w(
+    lib/jamie/core_ext.rb
+  )
+  cane.doc_exclude = %w(
+    lib/jamie/core_ext.rb
+  )
+end
+
+Tailor::RakeTask.new
+
+task :default => [ :cane, :tailor ]

data/jamie.gemspec

@@ -17,7 +17,11 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency 'hashie'
   gem.add_dependency 'mixlib-shellout'
   gem.add_dependency 'vagrant', '~> 1.0.5'
+
+  gem.add_development_dependency 'yard'
+  gem.add_development_dependency 'maruku'
+  gem.add_development_dependency 'cane'
+  gem.add_development_dependency 'tailor'
 end

data/lib/jamie.rb

@@ -1,111 +1,387 @@
 # -*- encoding: utf-8 -*-
 
-require 'hashie/dash'
-require 'mixlib/shellout'
 require 'yaml'
 
-require "jamie/version"
+require 'jamie/core_ext'
+require 'jamie/version'
 
 module Jamie
-  class Platform < Hashie::Dash
-    property :name, :required => true
-    property :vagrant_box
-    property :vagrant_box_url
-    property :base_run_list, :default => []
-  end
-
-  class Suite < Hashie::Dash
-    property :name, :required => true
-    property :run_list, :required => true
-    property :json, :default => Hash.new
-  end
 
+  # Base configuration class for Jamie. This class exposes configuration such
+  # as the location of the Jamie YAML file, instances, log_levels, etc.
   class Config
-    attr_writer :yaml
+
+    attr_writer :yaml_file
     attr_writer :platforms
     attr_writer :suites
-    attr_writer :backend
     attr_writer :log_level
     attr_writer :data_bags_base_path
 
-    def yaml
-      @yaml ||= File.join(Dir.pwd, '.jamie.yml')
+    # Default path to the Jamie YAML file
+    DEFAULT_YAML_FILE = File.join(Dir.pwd, '.jamie.yml').freeze
+
+    # Default log level verbosity
+    DEFAULT_LOG_LEVEL = :info
+
+    # Default driver plugin to use
+    DEFAULT_DRIVER_PLUGIN = "vagrant".freeze
+
+    # Default base path which may contain `data_bags/` directories
+    DEFAULT_DATA_BAGS_BASE_PATH = File.join(Dir.pwd, 'test/integration').freeze
+
+    # Creates a new configuration.
+    #
+    # @param yaml_file [String] optional path to Jamie YAML file
+    def initialize(yaml_file = nil)
+      @yaml_file = yaml_file
     end
 
+    # @return [Array<Platform>] all defined platforms which will be used in
+    #   convergence integration
     def platforms
-      @platforms ||=
-        Array(yaml_data["platforms"]).map { |hash| Platform.new(hash) }
+      @platforms ||= Array(yaml["platforms"]).map { |hash| new_platform(hash) }
     end
 
+    # @return [Array<Suite>] all defined suites which will be used in
+    #   convergence integration
     def suites
-      @suites ||=
-        Array(yaml_data["suites"]).map { |hash| Suite.new(hash) }
+      @suites ||= Array(yaml["suites"]).map { |hash| Suite.new(hash) }
     end
 
-    def backend
-      @backend ||= backend_for(yaml_data["backend"] || "vagrant")
+    # @return [Array<Instance>] all instances, resulting from all platform and
+    #   suite combinations
+    def instances
+      @instances ||= suites.map { |suite|
+        platforms.map { |platform| Instance.new(suite, platform) }
+      }.flatten
     end
 
+    # @return [String] path to the Jamie YAML file
+    def yaml_file
+      @yaml_file ||= DEFAULT_YAML_FILE
+    end
+
+    # @return [Symbol] log level verbosity
     def log_level
-      @log_level ||= :info
+      @log_level ||= DEFAULT_LOG_LEVEL
     end
 
+    # @return [String] base path that may contain a common `data_bags/`
+    #   directory or an instance's `data_bags/` directory
     def data_bags_base_path
-      default_path = File.join(Dir.pwd, 'test/integration')
+      @data_bags_path ||= DEFAULT_DATA_BAGS_BASE_PATH
+    end
 
-      @data_bags_path ||= File.directory?(default_path) ? default_path : nil
+    private
+
+    def new_platform(hash)
+      mpc = merge_platform_config(hash)
+      mpc['driver'] = new_driver(mpc['driver_plugin'], mpc['driver_config'])
+      Platform.new(mpc)
     end
 
-    def instances
-      result = []
-      suites.each do |suite|
-        platforms.each do |platform|
-          result << instance_name(suite, platform)
-        end
+    def new_driver(plugin, config)
+      Driver.for_plugin(plugin, config)
+    end
+
+    def yaml
+      @yaml ||= YAML.load_file(File.expand_path(yaml_file))
+    end
+
+    def merge_platform_config(platform_config)
+      default_driver_config.rmerge(common_driver_config.rmerge(platform_config))
+    end
+
+    def default_driver_config
+      { 'driver_plugin' => DEFAULT_DRIVER_PLUGIN }
+    end
+
+    def common_driver_config
+      yaml.select { |key, value| %w(driver_plugin driver_config).include?(key) }
+    end
+  end
+
+  # A Chef run_list and attribute hash that will be used in a convergence
+  # integration.
+  class Suite
+
+    # @return [String] logical name of this suite
+    attr_reader :name
+
+    # @return [Array] Array of Chef run_list items
+    attr_reader :run_list
+
+    # @return [Hash] Hash of Chef node attributes
+    attr_reader :json
+
+    # Constructs a new suite.
+    #
+    # @param [Hash] options configuration for a new suite
+    # @option options [String] :name logical name of this suit (**Required**)
+    # @option options [String] :run_list Array of Chef run_list items
+    #   (**Required**)
+    # @option options [Hash] :json Hash of Chef node attributes
+    def initialize(options = {})
+      validate_options(options)
+
+      @name = options['name']
+      @run_list = options['run_list']
+      @json = options['json'] || Hash.new
+    end
+
+    private
+
+    def validate_options(options)
+      if options['name'].nil?
+        raise ArgumentError, "The option 'name' is required."
+      end
+      if options['run_list'].nil?
+        raise ArgumentError, "The option 'run_list' is required."
       end
-      result
+    end
+  end
+
+  # A target operating system environment in which convergence integration
+  # will take place. This may represent a specific operating system, version,
+  # and machine architecture.
+  class Platform
+
+    # @return [String] logical name of this platform
+    attr_reader :name
+
+    # @return [Driver::Base] driver object which will manage this platform's
+    #   lifecycle actions
+    attr_reader :driver
+
+    # @return [Array] Array of Chef run_list items
+    attr_reader :run_list
+
+    # @return [Hash] Hash of Chef node attributes
+    attr_reader :json
+
+    # Constructs a new platform.
+    #
+    # @param [Hash] options configuration for a new platform
+    # @option options [String] :name logical name of this platform
+    #   (**Required**)
+    # @option options [Driver::Base] :driver subclass of Driver::Base which
+    #   will manage this platform's lifecycle actions (**Required**)
+    # @option options [Array<String>] :run_list Array of Chef run_list
+    #   items
+    # @option options [Hash] :json Hash of Chef node attributes
+    def initialize(options = {})
+      validate_options(options)
+
+      @name = options['name']
+      @driver = options['driver']
+      @run_list = Array(options['run_list'])
+      @json = options['json'] || Hash.new
     end
 
     private
 
-    def yaml_data
-      @yaml_data ||= YAML.load_file(yaml)
+    def validate_options(options)
+      if options['name'].nil?
+        raise ArgumentError, "The option 'name' is required."
+      end
+      if options['driver'].nil?
+        raise ArgumentError, "The option 'driver' is required."
+      end
     end
+  end
+
+  # An instance of a suite running on a platform. A created instance may be a
+  # local virtual machine, cloud instance, container, or even a bare metal
+  # server, which is determined by the platform's driver.
+  class Instance
 
-    def instance_name(suite, platform)
+    # @return [Suite] the test suite configuration
+    attr_reader :suite
+
+    # @return [Platform] the target platform configuration
+    attr_reader :platform
+
+    # Creates a new instance, given a suite and a platform.
+    #
+    # @param suite [Suite] a suite
+    # @param platform [Platform] a platform
+    def initialize(suite, platform)
+      @suite = suite
+      @platform = platform
+    end
+
+    # @return [String] name of this instance
+    def name
       "#{suite.name}-#{platform.name}".gsub(/_/, '-').gsub(/\./, '')
     end
 
-    def backend_for(backend)
-      klass = Jamie::Backend.const_get(backend.capitalize)
-      klass.new
+    # Returns a combined run_list starting with the platform's run_list
+    # followed by the suite's run_list.
+    #
+    # @return [Array] combined run_list from suite and platform
+    def run_list
+      Array(platform.run_list) + Array(suite.run_list)
+    end
+
+    # Returns a merged hash of Chef node attributes with values from the
+    # suite overriding values from the platform.
+    #
+    # @return [Hash] merged hash of Chef node attributes
+    def json
+      platform.json.rmerge(suite.json)
+    end
+
+    # Creates this instance.
+    #
+    # @see Driver::Base#create
+    # @return [self] this instance, used to chain actions
+    #
+    # @todo rescue Driver::ActionFailed and return some kind of null object
+    #   to gracfully stop action chaining
+    def create
+      puts "-----> Creating instance #{name}"
+      platform.driver.create(self)
+      puts "       Creation of instance #{name} complete."
+      self
+    end
+
+    # Converges this running instance.
+    #
+    # @see Driver::Base#converge
+    # @return [self] this instance, used to chain actions
+    #
+    # @todo rescue Driver::ActionFailed and return some kind of null object
+    #   to gracfully stop action chaining
+    def converge
+      puts "-----> Converging instance #{name}"
+      platform.driver.converge(self)
+      puts "       Convergence of instance #{name} complete."
+      self
+    end
+
+    # Verifies this converged instance by executing tests.
+    #
+    # @see Driver::Base#verify
+    # @return [self] this instance, used to chain actions
+    #
+    # @todo rescue Driver::ActionFailed and return some kind of null object
+    #   to gracfully stop action chaining
+    def verify
+      puts "-----> Verifying instance #{name}"
+      platform.driver.verify(self)
+      puts "       Verification of instance #{name} complete."
+      self
+    end
+
+    # Destroys this instance.
+    #
+    # @see Driver::Base#destroy
+    # @return [self] this instance, used to chain actions
+    #
+    # @todo rescue Driver::ActionFailed and return some kind of null object
+    #   to gracfully stop action chaining
+    def destroy
+      puts "-----> Destroying instance #{name}"
+      platform.driver.destroy(self)
+      puts "       Destruction of instance #{name} complete."
+      self
+    end
+
+    # Tests this instance by creating, converging and verifying. If this
+    # instance is running, it will be pre-emptively destroyed to ensure a
+    # clean slate. The instance will be left post-verify in a running state.
+    #
+    # @see #destroy
+    # @see #create
+    # @see #converge
+    # @see #verify
+    # @return [self] this instance, used to chain actions
+    #
+    # @todo rescue Driver::ActionFailed and return some kind of null object
+    #   to gracfully stop action chaining
+    def test
+      puts "-----> Cleaning up any prior instances of #{name}"
+      destroy
+      puts "-----> Testing instance #{name}"
+      create
+      converge
+      verify
+      puts "       Testing of instance #{name} complete."
+      self
     end
   end
 
-  module Backend
-    class CommandFailed < StandardError ; end
+  module Driver
+
+    # Wrapped exception for any internally raised driver exceptions.
+    class ActionFailed < StandardError ; end
+
+    # Returns an instance of a driver given a plugin type string.
+    #
+    # @param plugin [String] a driver plugin type, which will be constantized
+    # @return [Driver::Base] a driver instance
+    def self.for_plugin(plugin, config)
+      require "jamie/driver/#{plugin}"
+
+      klass = self.const_get(plugin.capitalize)
+      klass.new(config)
+    end
+
+    # Base class for a driver. A driver is responsible for carrying out the
+    # lifecycle activities of an instance, such as creating, converging, and
+    # destroying an instance.
+    class Base
+
+      def initialize(config)
+        @config = config
+        self.class.defaults.each do |attr, value|
+          @config[attr] = value unless @config[attr]
+        end
+      end
+
+      # Provides hash-like access to configuration keys.
+      #
+      # @param attr [Object] configuration key
+      # @return [Object] value at configuration key
+      def [](attr)
+        @config[attr]
+      end
+
+      # Creates an instance.
+      #
+      # @param instance [Instance] an instance
+      # @raise [ActionFailed] if the action could not be completed
+      def create(instance) ; end
+
+      # Converges a running instance.
+      #
+      # @param instance [Instance] an instance
+      # @raise [ActionFailed] if the action could not be completed
+      def converge(instance) ; end
 
-    class Vagrant
-      def up(instance)
-        exec! "vagrant up #{instance}"
-      rescue Mixlib::ShellOut::ShellCommandFailed => ex
-        raise CommandFailed, ex.message
+      # Destroys an instance.
+      #
+      # @param instance [Instance] an instance
+      # @raise [ActionFailed] if the action could not be completed
+      def destroy(instance) ; end
+
+      # Verifies a converged instance.
+      #
+      # @param instance [Instance] an instance
+      # @raise [ActionFailed] if the action could not be completed
+      def verify(instance)
+        # Subclass may choose to implement
+        puts "       Nothing to do!"
       end
 
-      def destroy(instance)
-        exec! "vagrant destroy #{instance} -f"
-      rescue Mixlib::ShellOut::ShellCommandFailed => ex
-        raise CommandFailed, ex.message
+      private
+
+      def self.defaults
+        @defaults ||= Hash.new
       end
 
-      def exec!(cmd)
-        puts "-----> [vagrant command] #{cmd}"
-        shellout = Mixlib::ShellOut.new(
-          cmd, :live_stream => STDOUT, :timeout => 60000
-        )
-        shellout.run_command
-        puts "-----> Command '#{cmd}' ran in #{shellout.execution_time} seconds."
-        shellout.error!
+      def self.default_config(attr, value)
+        defaults[attr] = value
       end
     end
   end

data/lib/jamie/core_ext.rb

@@ -0,0 +1,74 @@
+#
+# = Hash Recursive Merge
+#
+# Merges a Ruby Hash recursively, Also known as deep merge.
+# Recursive version of Hash#merge and Hash#merge!.
+#
+# Category::    Ruby
+# Package::     Hash
+# Author::      Simone Carletti <weppos@weppos.net>
+# Copyright::   2007-2008 The Authors
+# License::     MIT License
+# Link::        http://www.simonecarletti.com/
+# Source::      http://gist.github.com/gists/6391/
+#
+module HashRecursiveMerge
+
+  #
+  # Recursive version of Hash#merge!
+  #
+  # Adds the contents of +other_hash+ to +hsh+,
+  # merging entries in +hsh+ with duplicate keys with those from +other_hash+.
+  #
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  #
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge!(h2)   #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+  #
+  # Simply using Hash#merge! would return
+  #
+  #    h1.merge!(h2)    #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+  #
+  def rmerge!(other_hash)
+    merge!(other_hash) do |key, oldval, newval|
+      oldval.class == self.class ? oldval.rmerge!(newval) : newval
+    end
+  end
+
+  #
+  # Recursive version of Hash#merge
+  #
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  #
+  # Compared with Hash#merge, this method provides a different approch
+  # for merging nasted hashes.
+  # If the value of a given key is an Hash and both +other_hash+ abd +hsh
+  # includes the same key, the value is merged instead replaced with
+  # +other_hash+ value.
+  #
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge(h2)    #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+  #
+  # Simply using Hash#merge would return
+  #
+  #    h1.merge(h2)     #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+  #
+  def rmerge(other_hash)
+    r = {}
+    merge(other_hash) do |key, oldval, newval|
+      r[key] = oldval.class == self.class ? oldval.rmerge(newval) : newval
+    end
+  end
+
+end
+
+
+class Hash
+  include HashRecursiveMerge
+end

data/lib/jamie/driver/vagrant.rb

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+require 'mixlib/shellout'
+
+require 'jamie'
+
+module Jamie
+
+  module Driver
+
+    # Vagrant driver for Jamie. It communicates to Vagrant via the CLI.
+    class Vagrant < Jamie::Driver::Base
+
+      default_config 'memory', '256'
+
+      def create(instance)
+        run "vagrant up #{instance.name} --no-provision"
+      end
+
+      def converge(instance)
+        run "vagrant provision #{instance.name}"
+      end
+
+      def destroy(instance)
+        run "vagrant destroy #{instance.name} -f"
+      end
+
+      private
+
+      def run(cmd)
+        puts "       [vagrant command] '#{cmd}'"
+        shellout = Mixlib::ShellOut.new(
+          cmd, :live_stream => STDOUT, :timeout => 60000
+        )
+        shellout.run_command
+        puts "       [vagrant command] '#{cmd}' ran " +
+          "in #{shellout.execution_time} seconds."
+        shellout.error!
+      rescue Mixlib::ShellOut::ShellCommandFailed => ex
+        raise ActionFailed, ex.message
+      end
+    end
+  end
+end

data/lib/jamie/rake_tasks.rb

@@ -0,0 +1,55 @@
+# -*- encoding: utf-8 -*-
+
+require 'rake'
+require 'rake/tasklib'
+
+require 'jamie'
+
+module Jamie
+
+  # Jamie Rake task generator.
+  class RakeTasks < ::Rake::TaskLib
+
+    # @return [String] prefix name of all Jamie tasks
+    attr_accessor :name
+
+    # @return [Jamie::Config] a Jamie config object
+    attr_accessor :config
+
+    # Creates Jamie Rake tasks and allows the callee to configure it.
+    #
+    # @yield [self] gives itself to the block
+    def initialize(name = :jamie)
+      @name = name
+      @config = Jamie::Config.new
+      yield self if block_given?
+      define
+    end
+
+    private
+
+    def define
+      namespace name do
+        config.instances.each do |instance|
+          desc "Run #{instance.name} test instance"
+          task instance.name do
+            instance.test
+          end
+
+          namespace instance.name do
+            desc "Destroy #{instance.name} test instance"
+            task :destroy do
+              instance.destroy
+            end
+          end
+        end
+
+        desc "Destroy all instances"
+        task :destroy => config.instances.map { |i| "#{i.name}:destroy" }
+      end
+
+      desc "Run Jamie integration"
+      task name => config.instances.map { |i| "#{name}:#{i.name}" }
+    end
+  end
+end

data/lib/jamie/vagrant.rb

@@ -6,12 +6,15 @@ require 'vagrant'
 require 'jamie'
 
 module Jamie
+
   module Vagrant
+
+    # A Vagrant confiuration class which wraps a Jamie::Config instance.
     class Config < ::Vagrant::Config::Base
       extend Forwardable
 
-      def_delegators :@config, :yaml, :yaml=, :platforms, :platforms=,
-        :suites, :suites=, :log_level, :log_level=,
+      def_delegators :@config, :suites, :suites=, :platforms, :platforms=,
+        :instances, :yaml_file, :yaml_file=, :log_level, :log_level=,
         :data_bags_base_path, :data_bags_base_path=, :yaml_data
 
       def initialize
@@ -19,41 +22,38 @@ module Jamie
       end
     end
 
-    def self.init!
-      ::Vagrant.config_keys.register(:jamie) { Jamie::Vagrant::Config }
-    end
-
+    # Defines all Vagrant virtual machines, one for each instance.
+    #
+    # @param config [Vagrant::Config::Top] Vagrant top level config object
     def self.define_vms(config)
-      config.jamie.suites.each do |suite|
-        config.jamie.platforms.each do |platform|
-          define_vagrant_vm(config, suite, platform)
-        end
+      config.jamie.instances.each do |instance|
+        define_vagrant_vm(config, instance)
       end
     end
 
     private
 
-    def self.define_vagrant_vm(config, suite, platform)
-      name = "#{suite.name}-#{platform.name}".gsub(/_/, '-').gsub(/\./, '')
+    def self.define_vagrant_vm(config, instance)
+      driver = instance.platform.driver
 
-      config.vm.define name do |c|
-        c.vm.box = platform.vagrant_box
-        c.vm.box_url = platform.vagrant_box_url if platform.vagrant_box_url
-        c.vm.host_name = "#{name}.vagrantup.com"
-        c.vm.customize ["modifyvm", :id, "--memory", "256"]
+      config.vm.define instance.name do |c|
+        c.vm.box = driver['box']
+        c.vm.box_url = driver['box_url'] if driver['box_url']
+        c.vm.host_name = "#{instance.name}.vagrantup.com"
+        c.vm.customize ["modifyvm", :id, "--memory", driver['memory']]
 
         c.vm.provision :chef_solo do |chef|
           chef.log_level = config.jamie.log_level
-          chef.run_list = platform.base_run_list + Array(suite.run_list)
-          chef.json = suite.json
-          chef.data_bags_path = calculate_data_bags_path(config, name)
+          chef.run_list = instance.run_list
+          chef.json = instance.json
+          chef.data_bags_path = calculate_data_bags_path(config, instance)
         end
       end
     end
 
-    def self.calculate_data_bags_path(config, instance_name)
+    def self.calculate_data_bags_path(config, instance)
       base_path = config.jamie.data_bags_base_path
-      instance_data_bags_path = File.join(base_path, instance_name, "data_bags")
+      instance_data_bags_path = File.join(base_path, instance.name, "data_bags")
       common_data_bags_path = File.join(base_path, "data_bags")
 
       if File.directory?(instance_data_bags_path)
@@ -67,4 +67,4 @@ module Jamie
   end
 end
 
-Jamie::Vagrant.init!
+Vagrant.config_keys.register(:jamie) { Jamie::Vagrant::Config }

data/lib/jamie/version.rb

@@ -1,3 +1,6 @@
+# -*- encoding: utf-8 -*-
+
 module Jamie
-  VERSION = "0.1.0.alpha1"
+
+  VERSION = "0.1.0.alpha2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jamie
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha1
+  version: 0.1.0.alpha2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,10 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-01 00:00:00.000000000 Z
+date: 2012-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: hashie
+  name: mixlib-shellout
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -28,14 +28,30 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mixlib-shellout
+  name: vagrant
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
@@ -44,21 +60,53 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: vagrant
+  name: maruku
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.5
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.5
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cane
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tailor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A Chef convergence integration test harness
 email:
 - fnichol@nichol.ca
@@ -67,13 +115,17 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
+- .yardopts
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - jamie.gemspec
 - lib/jamie.rb
-- lib/jamie/rake_task.rb
+- lib/jamie/core_ext.rb
+- lib/jamie/driver/vagrant.rb
+- lib/jamie/rake_tasks.rb
 - lib/jamie/vagrant.rb
 - lib/jamie/version.rb
 homepage: ''
@@ -88,6 +140,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -4553058254287566395
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -101,3 +156,4 @@ signing_key:
 specification_version: 3
 summary: A Chef convergence integration test harness
 test_files: []
+has_rdoc: 

data/lib/jamie/rake_task.rb

@@ -1,52 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'rake'
-require 'rake/tasklib'
-
-require 'jamie'
-
-module Jamie
-  module Rake
-    class Tasks < ::Rake::TaskLib
-      attr_accessor :name
-
-      def initialize(name = :jamie)
-        @name = name
-        yield self if block_given?
-        define
-      end
-
-      def define
-        config = Jamie::Config.new
-
-        namespace(name) do
-          config.instances.each do |instance_name|
-            desc "Run #{instance_name} integration"
-            task(instance_name) do
-              puts "-----> Cleaning up any prior instances of #{instance_name}"
-              config.backend.destroy(instance_name)
-              puts "-----> Bringing up instance #{instance_name}"
-              config.backend.up(instance_name)
-              puts "-----> Instance #{instance_name} completed."
-            end
-
-            namespace(instance_name) do
-              desc "Destroy #{instance_name} instance"
-              task :destroy do
-                puts "-----> Destroying any prior instances of #{instance_name}"
-                config.backend.destroy(instance_name)
-                puts "-----> Instance #{instance_name} destruction complete."
-              end
-            end
-          end
-
-          desc "Destroy all instances"
-          task :destroy => config.instances.map { |i| "#{i}:destroy" }
-        end
-
-        desc "Run Jamie integration"
-        task name => config.instances
-      end
-    end
-  end
-end