vagrant-pirate 0.2.0

data/features/ship.feature

@@ -0,0 +1,28 @@
+Feature: Init command
+
+  In order to start using a YAML-based Vagrant project
+  As a user using vagrant-pirate
+  I want to initialize a new project
+
+  Scenario: Running 'vagrant pirate ship'
+    Given a directory named "test"
+    And I cd to "test"
+    When I successfully run `vagrant pirate ship`
+    Then the following directories should exist:
+      | local.d |
+      | available.d |
+      | enabled.d |
+    And the following files should exist:
+      | Vagrantfile |
+      | available.d/default.yaml |
+      | enabled.d/vm1.yaml |
+      | enabled.d/vm2.yaml |
+      | local.d/vm1.yaml |
+      | local.d/vm2.yaml |
+    And the output should contain "A `Vagrantfile` has been placed in this directory, a default Yaml VM config file"
+    And the output should contain "has been placed in 'available.d', and a symlink to it, placed in 'enabled.d'."
+    And the output should contain "Finally, a file to contain local overrides was placed in 'local.d'. Unlike a"
+    And the output should contain "regular Vagrantfile, this one parses and applies the configuration in the Yaml"
+    And the output should contain "files it finds in 'enabled.d'. You are now ready to `vagrant up` your first"
+    And the output should contain "virtual environment! Please read the comments in the default Yaml VM config"
+    And the output should contain "file to see how it works."

data/features/support/env.rb

@@ -0,0 +1,9 @@
+# Since simplecov need to run in the same process as the code being annalized,
+# we run initialize simplecov at the very beginning of our plugin. To only do
+# so during tests, we wrap it in a check for an environment variable.
+ENV['COVERAGE'] = 'true'
+require 'coveralls'
+# Since simplecov is running under a separate process, we need to retrieve the
+# results afterwards.
+Coveralls.wear_merged!
+require 'aruba/cucumber'

data/lib/vagrant-pirate/command/pirate.rb

@@ -0,0 +1,69 @@
+require 'optparse'
+
+module VagrantPlugins
+  module VagrantPirate
+    module Command
+      class Pirate < Vagrant.plugin("2", :command)
+        def self.synopsis
+          "Manage YAML-based projects."
+        end
+
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:ship) do
+            require File.expand_path("../pirate_ship", __FILE__)
+            PirateShip
+          end
+
+          @subcommands.register(:update) do
+            require File.expand_path("../pirate_update", __FILE__)
+            PirateUpdate
+          end
+        end
+
+        def execute
+          if @main_args.include?("-h") || @main_args.include?("--help")
+            # Print the help for all the box commands.
+            return help
+          end
+
+          # If we reached this far then we must have a subcommand. If not,
+          # then we also just print the help and exit.
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        # Prints the help out for this command
+        def help
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant pirate <command> [<args>]"
+            opts.separator ""
+            opts.separator "Available subcommands:"
+
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, value| keys << key.to_s }
+
+            keys.sort.each do |key|
+              opts.separator "     #{key}"
+            end
+
+            opts.separator ""
+            opts.separator "For help on any individual command run `vagrant pirate COMMAND -h`"
+          end
+
+          @env.ui.info(opts.help, :prefix => false)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-pirate/command/pirate_ship.rb

@@ -0,0 +1,84 @@
+require 'optparse'
+require 'vagrant/util/template_renderer'
+
+module VagrantPlugins
+  module VagrantPirate
+    module Command
+      class PirateShip < Vagrant.plugin("2", :command)
+
+        def self.synopsis
+          "Initializes a new Vagrant environment by creating a Vagrantfile and YAML config files."
+        end
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant pirate ship [box-name] [box-url]"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+
+          create_vagrantfile
+          create_directories
+          create_default_yaml(argv[0], argv[1])
+          create_vm_yaml('vm1')
+          create_vm_yaml('vm2')
+
+          @env.ui.info(I18n.t(
+            "vagrant.plugins.pirate.commands.ship.success",
+              avail_dir: 'available.d',
+              enabled_dir: 'enabled.d',
+              local_dir: 'local.d'
+            ), :prefix => false)
+          # Success, exit status 0
+          0
+        end
+
+        def create_vagrantfile
+          save_path = @env.cwd.join("Vagrantfile")
+          raise Errors::VagrantfileExistsError if save_path.exist?
+
+          template_path = ::VagrantPirate.source_root.join("templates/Vagrantfile")
+          contents = Vagrant::Util::TemplateRenderer.render(template_path)
+          save_path.open("w+") do |f|
+            f.write(contents)
+          end
+        end
+
+        def create_directories
+          Dir.mkdir('available.d')
+          Dir.mkdir('enabled.d')
+          Dir.mkdir('local.d')
+        end
+
+        def create_default_yaml(box_name=nil, box_url=nil)
+          save_path = @env.cwd.join("available.d/default.yaml")
+          raise Errors::VagrantfileExistsError if save_path.exist?
+
+          template_path = ::VagrantPirate.source_root.join("templates/default.yaml")
+          contents = Vagrant::Util::TemplateRenderer.render(template_path,
+                                                            :box_name => box_name,
+                                                            :box_url => box_url)
+          save_path.open("w+") do |f|
+            f.write(contents)
+          end
+        end
+
+        def create_vm_yaml(vm_name)
+          File.symlink("../available.d/default.yaml", "enabled.d/" + vm_name + ".yaml")
+          save_path = @env.cwd.join("local.d/" + vm_name + ".yaml")
+          raise Errors::VagrantfileExistsError if save_path.exist?
+          template_path = ::VagrantPirate.source_root.join("templates/local.yaml")
+          contents = Vagrant::Util::TemplateRenderer.render(template_path,
+                                                            :hostname => vm_name + ".example.com")
+          save_path.open("w+") do |f|
+            f.write(contents)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-pirate/command/pirate_update.rb

@@ -0,0 +1,77 @@
+require 'optparse'
+require 'vagrant/util/template_renderer'
+
+module VagrantPlugins
+  module VagrantPirate
+    module Command
+      class PirateUpdate < Vagrant.plugin("2", :command)
+        def self.synopsis
+          "Updates a YAML-based Vagrant environment."
+        end
+
+        def execute
+          options = {}
+
+          # Boolean whether we should actually go through with the update
+          # or not. This is true only if the "--force" flag is set or if the
+          # user confirms it.
+          do_update = false
+
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant pirate update"
+
+            opts.on("-f", "--force", "Update without confirmation.") do |f|
+              options[:force] = f
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+
+          if options[:force]
+            do_update = true
+          else
+            choice = nil
+            begin
+              choice = @env.ui.ask(I18n.t("vagrant.plugins.pirate.commands.update.confirmation"))
+
+            rescue Errors::UIExpectsTTY
+              # We raise a more specific error but one which basically
+              # means the same thing.
+              raise Errors::UpdateRequiresForce
+            end
+            do_update = choice.upcase == "Y"
+          end
+
+          if do_update
+            @logger.info("Updating project with latest Vagrantfile from vagrant-pirate.")
+            update
+          else
+            @logger.info("Not updating project since confirmation was declined.")
+            @env.ui.success(I18n.t("vagrant.plugins.pirate.commands.update.will_not_update"),
+                              :prefix => false)
+          end
+        end
+
+        def update
+          save_path = @env.cwd.join("Vagrantfile")
+
+          template_path = ::VagrantPirate.source_root.join("templates/Vagrantfile")
+          contents = Vagrant::Util::TemplateRenderer.render(template_path)
+
+          # Write out the contents
+          save_path.open("w+") do |f|
+            f.write(contents)
+          end
+
+          @env.ui.info(I18n.t("vagrant.plugins.pirate.commands.update.success"),
+                       :prefix => false)
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-pirate/config/pirate.rb

@@ -0,0 +1,32 @@
+module VagrantPlugins
+  module VagrantPirate
+    module Config
+      class Pirate < Vagrant.plugin("2", :config)
+        attr_accessor :map
+
+        def initialize
+          @map = UNSET_VALUE
+        end
+
+        def finalize!
+          if @map == UNSET_VALUE
+            @map = { "local" => "local.d", "enabled" => "vms-enabled" }
+          end
+        end
+
+        def validate(machine)
+          errors = _detected_errors
+          @map.each() do |name, conf_dir|
+            current_dir = Dir.pwd + '/' + conf_dir
+            if !File.directory?(current_dir)
+              errors << "Configuration directories must exist: #{current_dir}"
+            end
+          end
+
+          { "pirate" => errors }
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-pirate/errors.rb

@@ -0,0 +1,17 @@
+module VagrantPirate
+  module Errors
+
+    class PirateError < Vagrant::Errors::VagrantError
+      def error_namespace; "vagrant.plugins.pirate.errors"; end
+    end
+
+    class VagrantfileExistsError < PirateError
+      error_key :vagrantfile_exists
+    end
+
+    class EnabledDirMissing < PirateError
+      error_key :enabled_dir_missing
+    end
+
+  end
+end

data/lib/vagrant-pirate/plugin.rb

@@ -0,0 +1,33 @@
+require 'vagrant-pirate/vagrant-pirate'
+
+module VagrantPlugins
+  module VagrantPirate
+    class Plugin < Vagrant.plugin("2")
+      name "Yagrant YAML"
+      description <<-DESC
+      This plugin enables Vagrant to use YAML files to configure VMs.
+      DESC
+
+      config("pirate") do
+        require_relative "config/pirate"
+        Config::Pirate
+      end
+
+      command("pirate") do
+        require_relative "command/pirate"
+        Command::Pirate
+      end
+
+      command("pirate-ship", primary: false) do
+        require_relative "command/pirate_ship"
+        Command::PirateShip
+      end
+
+      command("pirate-update", primary: false) do
+        require_relative "command/pirate_update"
+        Command::PirateUpdate
+      end
+    end
+  end
+end
+

data/lib/vagrant-pirate/vagrant-pirate.rb

@@ -0,0 +1,92 @@
+module VagrantPirate
+  # The source root is the path to the root directory of the this gem.
+  def self.source_root
+    @source_root ||= Pathname.new(File.expand_path('../../../', __FILE__))
+  end
+
+  # Apply settings loaded from YAML to a vm.
+  def self.ahoy!(vm,yml)
+    yml.each do |key0,value0|
+      if !value0.is_a?(Hash)                           # If it's a setting,
+          vm.send("#{key0}=".to_sym, value0)           # we set it directly.
+      else                                               # Otherwise,
+        method_object = vm.method("#{key0}".to_sym)      # we're invoking a method
+        value0.each do |key1,value1|                     # and each setting
+          method_object.call("#{key1}".to_sym, value1)   # needs to be passed to the method.
+        end
+      end
+    end
+  end
+
+  # Merge hashes recursively
+  def self.sail_ho!(first, second)
+    second.each_pair do |k,v|
+      if first[k].is_a?(Hash) and second[k].is_a?(Hash)
+        deep_merge!(first[k], second[k])
+      else
+        first[k] = second[k]
+      end
+    end
+  end
+
+  
+  def self.Arrr!(plunder)
+    require "yaml"
+
+    # Set defaults
+    local_dir = "local.d"
+    enabled_dir = "enabled.d"
+    # Override defaults with config, if it's set, since config finalizing
+    # occurs too late for our purposes.
+    if plunder.pirate.map.is_a?(Hash)
+      if plunder.pirate.map.has_key?('local')
+        local_dir = plunder.pirate.map['local']
+      end
+      if plunder.pirate.map.has_key?('enabled')
+        enabled_dir = plunder.pirate.map['enabled']
+      end
+    end
+
+    # All paths are relative to the project root
+    # todo: Can we access this from Vagrant::Environment?
+    current_dir = Dir.pwd
+    local_dir = "#{current_dir}/#{local_dir}"
+    enabled_dir = "#{current_dir}/#{enabled_dir}"
+
+    # Scan our vms-enabled/ directory for YAML config files
+    if File.directory?(enabled_dir)
+      config_files = Dir.glob("#{enabled_dir}/*.yaml")
+    else
+      raise Errors::EnabledDirMissing,
+        :enabled_dir => enabled_dir
+    end
+
+    # Build up a list of the VMs we'll provision, and their config_files
+    vms = {}
+    config_files.each do |config_file|
+      vms.update({ File.basename(config_file, ".yaml") => config_file})
+    end
+
+    # VM-specific configuration loaded from YAML config files
+    vms.each do |vm,config_file|
+
+      yml = YAML.load_file config_file
+      yml = {} if !yml.is_a?(Hash)
+
+      # Allow local overrides
+      local_file = "#{local_dir}/#{vm}.yaml"
+      if File.exists?(local_file)
+        local = YAML.load_file local_file
+        sail_ho!(yml, local) if local.is_a?(Hash)
+      end
+
+      plunder.vm.define "#{vm}" do |vm_config|
+        ahoy!(vm_config.vm, yml)
+        # We may need some project-wide config file to handle things like:
+        #vm_config.vbguest.auto_update = false
+      end
+
+    end
+
+  end
+end

data/lib/vagrant-pirate/version.rb

@@ -0,0 +1,3 @@
+module VagrantPirate
+  VERSION = "0.2.0"
+end

data/lib/vagrant-pirate.rb

@@ -0,0 +1,17 @@
+# Since Vagrant starts under a different process from our tests, we need to
+# initialize simplecov here, and make it available for coveralls to retrieve.
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.command_name "binary #{Process.pid}"
+  SimpleCov.root(File.expand_path('../../', __FILE__))
+  SimpleCov.start
+end
+
+
+require 'vagrant'
+require 'vagrant-pirate/errors'
+require 'vagrant-pirate/plugin'
+require 'vagrant-pirate/vagrant-pirate'
+
+# Add our custom translations to the load path
+I18n.load_path << File.expand_path("../../locales/en.yml", __FILE__)

data/locales/en.yml

@@ -0,0 +1,32 @@
+en:
+  vagrant:
+    plugins:
+      pirate:
+        commands:
+          ship:
+            success: |-
+              A `Vagrantfile` has been placed in this directory, a default Yaml VM config file
+              has been placed in '%{avail_dir}', and a symlink to it, placed in '%{enabled_dir}'.
+              Finally, a file to contain local overrides was placed in '%{local_dir}'. Unlike a
+              regular Vagrantfile, this one parses and applies the configuration in the Yaml
+              files it finds in '%{enabled_dir}'. You are now ready to `vagrant up` your first
+              virtual environment! Please read the comments in the default Yaml VM config
+              file to see how it works.
+          update:
+            success: |-
+              Vagrantfile updated using the latest one from vagrant-pirate.
+            confirmation: |-
+              This operation will overwrite the Vagrantfile in this project with the one in the
+              vagrant-pirate gem. Do you want to proceed?
+            will_not_update: |-
+              User aborted. Vagrantfile was not updated.
+
+        errors:
+          vagrantfile_exists: |-
+            `Vagrantfile` already exists in this directory. Remove it before running `vagrant
+            pirate init`, or run `vagrant pirate update` to update to the latest version.
+          enabled_dir_missing: |-
+            A valid directory must be specified where YAML configs for the VMs can be found.
+            Current config points to a non-existent directory:
+            >>> %{enabled_dir}
+

data/tasks/cucumber.rake

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'coveralls/rake/task'
+
+desc 'Default task which runs all cucumber tests'
+Coveralls::RakeTask.new
+task :default => [:features, 'coveralls:push']
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --no-source --format pretty"
+end

data/templates/Vagrantfile.erb

@@ -0,0 +1,16 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version.
+# Don't be touching this, Matey, lest ye send us all down to Dany Jones' locker!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |plunder|
+
+  # Specify the directories in which to look for YAML VM config files.
+  #plunder.pirate.map = { 'local' => 'local.d', 'enabled' => 'enabled.d' }
+
+  # Load, parse and apply YAML VM configs.
+  Pirate::Arrr!(plunder)
+
+end

data/templates/default.yaml.erb

@@ -0,0 +1,39 @@
+# All Vagrant VM configuration can be done from Yaml config files such as this
+# one. Only config files in the 'enabled.d' directory are interpreted. You
+# can copy from, or symlink to, files in the 'available.d' directory. This
+# allows you to have a library of config files that could, for example, be
+# updated by an external application.
+
+# Also, any Yaml config file in local.d/ named the same as one in enabled.d/
+# will allow the selective override of individual configuration settings. See
+# local.d/vm1.yaml for an example.
+
+# To see what you can do with Yaml, check out this handy reference card:
+# http://www.yaml.org/refcard.html. To see how Yaml is interpreted in Ruby, see
+# this guide: http://yaml.org/YAML_for_ruby.html. For further details, refer to
+# the full Yaml specification: http://www.yaml.org/spec/1.2/spec.html
+
+# For all available Vagrant options, see the docs on Vagrantfile settings:
+# http://vagrantup.com/v2/docs/vagrantfile.html. While we've provided some
+# examples below, it's far from exhaustive. If you can't figure out how to
+# apply a particular setting, please file a support request at:
+# https://github.com/PraxisLabs/vagrant-pirate. Also, feel free to post to the
+# project's wiki, or submit pull requests.
+
+box: "<%= box_name || "base" %>"
+<% if box_url.nil? %># <% end %>box_url: "<%= box_url || "http://domain.com/path/to/above.box" %>"
+hostname: &id001 vagrant.local
+#network:
+#  forwarded_port:
+#    :guest: 80
+#    :host:  8080
+#provision:
+#  puppet:
+#    :module_path: 'modules'
+#    :manifests_path: 'manifests'
+#    :manifest_file: site.pp
+#    :options:
+#      - --verbose
+#      - --debug
+#    :facter:
+#      fqdn: *id001

data/templates/local.yaml.erb

@@ -0,0 +1,6 @@
+# Any Yaml config file in 'local.d/' named the same as one in 'enabled.d/' will
+# allow the selective override of individual configuration settings. Uncommen-
+# ting the setting below would override the 'hostname' set by Vagrant in the
+# VM.
+
+hostname: <%= hostname %>

data/vagrant-pirate.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/vagrant-pirate/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "vagrant-pirate"
+  s.version     = VagrantPirate::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Christopher Gervais"]
+  s.email       = ["chris@ergonlogic.com"]
+  s.license     = 'GPL'
+  s.homepage    = "https://github.com/PraxisLabs/vagrant-pirate"
+  s.summary     = %q{A Vagrant plugin that allows configuration via YAML}
+  s.description = %q{A Vagrant plugin that allows configuration via YAML}
+
+  s.required_ruby_version = '>= 2.0.0'
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_development_dependency "cucumber"
+  s.add_development_dependency "aruba"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "simplecov", '~> 0.7.1'
+  s.add_development_dependency "coveralls"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+end