nugrant 0.0.11

data/lib/nugrant/parameters.rb

@@ -0,0 +1,104 @@
+require 'deep_merge'
+require 'json'
+require 'ostruct'
+require 'yaml'
+
+module Nugrant
+  class Parameters < Nugrant::ParameterBag
+    def initialize(config = nil)
+      if config == nil
+        config = Nugrant::Config.new()
+      end
+
+      @config = config
+      @parameters = load_parameters()
+
+      super(@parameters)
+    end
+
+    def get_bag()
+      @bag
+    end
+
+    def get_params()
+      return @parameters
+    end
+
+    def get_project_params()
+      return @project_parameters
+    end
+
+    def get_user_params()
+      return @user_parameters
+    end
+
+    def get_system_params()
+      return @system_parameters
+    end
+
+    def load_parameters()
+      @project_parameters = load_parameters_file(@config.project_params_path)
+      @user_parameters = load_parameters_file(@config.user_params_path)
+      @system_parameters = load_parameters_file(@config.system_params_path)
+
+      parameters = Hash.new()
+
+      if @project_parameters == nil and @user_parameters == nil and @system_parameters == nil
+        return parameters
+      end
+
+      parameters.deep_merge!(@system_parameters) if @system_parameters != nil
+      parameters.deep_merge!(@user_parameters) if @user_parameters != nil
+      parameters.deep_merge!(@project_parameters) if @project_parameters != nil
+
+      return parameters
+    end
+
+    def load_parameters_file(file_path)
+      if not File.exists?(file_path)
+        return nil
+      end
+
+      begin
+        File.open(file_path, "rb") do |file|
+          parsing_method = "parse_#{@config.params_filetype}"
+          result = send(parsing_method, file.read)
+
+          restricted_key = has_restricted_keys?(result)
+          if restricted_key
+            raise ArgumentError, "The key '#{restricted_key}' has restricted usage and cannot be defined"
+          end
+
+          return result
+        end
+      rescue => error
+        raise RuntimeError, "Could not parse the user #{@config.params_filetype} parameters file '#{file_path}': #{error}"
+      end
+    end
+
+    def parse_json(data_string)
+      JSON.parse(data_string)
+    end
+
+    def parse_yml(data_string)
+      YAML::ENGINE.yamler= 'syck' if defined?(YAML::ENGINE)
+
+      YAML.load(data_string)
+    end
+
+    def has_restricted_keys?(parameters)
+      parameters.each do |key, value|
+        if key == "defaults"
+          return "defaults"
+        end
+
+        if value.is_a?(Hash)
+          result = has_restricted_keys?(value)
+          return result if result
+        end
+      end
+
+      return false
+    end
+  end
+end

data/lib/nugrant/vagrant/user_command.rb

@@ -0,0 +1,86 @@
+require 'nugrant'
+
+module Nugrant
+  module Vagrant
+    class UserCommand < ::Vagrant::Command::Base
+      HANDLED_SUBCOMMANDS = [
+        "parameters",
+      ]
+
+      def initialize(arguments, environment)
+        super(arguments, environment)
+
+        @parameters = Nugrant::Parameters.new()
+        @options_parser = initialize_parsers()
+
+        @print_help = false
+      end
+
+      def initialize_parsers()
+        parser = OptionParser.new
+
+        parser.banner = "Usage: vagrant user subcommand [options]"
+
+        parser.on("-h", "--help", "Print this help") do
+          @print_help
+        end
+
+        parser.separator ""
+        parser.separator "Available subcommands:"
+
+        HANDLED_SUBCOMMANDS.each do |subcommand|
+          parser.separator "     #{subcommand}"
+        end
+
+        return parser
+      end
+
+      def execute()
+        subcommands = parse_options(@options_parser)
+        if not subcommands
+          subcommands = ["parameters"]
+        end
+
+        subcommands = validate_subcommands(subcommands)
+        if not subcommands
+          safe_puts(@options_parser.help())
+          return
+        end
+
+        # At this point, subcommands are valid
+        subcommands.each do |subcommand|
+          execute_subcommand(subcommand)
+        end
+      end
+
+      def execute_subcommand(subcommand)
+        send(:parameters)
+      end
+
+      def parameters()
+        parameters = {
+          'config' => {
+            'user' => @parameters.get_params()
+          }
+        }
+
+        safe_puts(parameters.to_yaml(:Separator => ""))
+      end
+
+      def handled_subcommand?(subcommand)
+        return HANDLED_SUBCOMMANDS.find_index(subcommand)
+      end
+
+      def validate_subcommands(subcommands)
+        subcommands.each do |subcommand|
+          if not handled_subcommand?(subcommand)
+            puts "Unknown subcommand [#{subcommand}]."
+            return nil
+          end
+        end
+
+        return subcommands
+      end
+    end
+  end
+end

data/lib/nugrant/vagrant/user_parameters.rb

@@ -0,0 +1,27 @@
+require 'nugrant'
+
+module Nugrant
+  module Vagrant
+    class UserParameters < ::Vagrant::Config::Base
+      def initialize()
+        @parameters = Nugrant::Parameters.new()
+      end
+
+      def [](param_name)
+        return @parameters[param_name]
+      end
+
+      def method_missing(method, *args, &block)
+        return @parameters.method_missing(method, *args, &block)
+      end
+
+      def defaults(parameters)
+        @parameters.defaults(parameters)
+      end
+
+      def defaults=(parameters)
+        @parameters.defaults=(parameters)
+      end
+    end
+  end
+end

data/lib/nugrant/version.rb

@@ -0,0 +1,3 @@
+module Nugrant
+  VERSION = "0.0.11"
+end

data/lib/vagrant_init.rb

@@ -0,0 +1,7 @@
+# This module will initialize the vagrant plugin
+require 'nugrant/vagrant/user_command'
+require 'nugrant/vagrant/user_parameters'
+
+# Plugin bootstrap
+Vagrant.commands.register(:user) { Nugrant::Vagrant::UserCommand }
+Vagrant.config_keys.register(:user) { Nugrant::Vagrant::UserParameters }

data/nugrant.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'nugrant/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "nugrant"
+  gem.version       = Nugrant::VERSION
+  gem.authors       = ["Matthieu Vachon"]
+  gem.email         = ["matthieu.ouellette-vachon@nuecho.com"]
+  gem.homepage      = "https://github.com/nuecho/nugrant"
+  gem.summary       = "Vagrant plugin to enable user specific configuration parameters."
+  gem.description   = <<-EOF
+     This gem is in fact a Vagrant pluging. By installing this gem, it will be
+     possible to define user specific configuration files that will be merge
+     directly into the Vagrant configuration. This is usefull if you need to
+     share a Vagrantfile to multiple developers but would like to customize
+     some parameters for each users differently.
+  EOF
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "deep_merge", "~> 1.0.0"
+
+  gem.add_development_dependency "rake", "~> 0.9.0"
+  gem.add_development_dependency "vagrant", "~> 1.0.5"
+end

data/test/lib/nugrant/test_config.rb

@@ -0,0 +1,125 @@
+require 'nugrant/config'
+require 'test/unit'
+require 'tmpdir'
+
+class Nugrant::TestConfig < Test::Unit::TestCase
+  def setup
+    @default_param_filename = Nugrant::Config::DEFAULT_PARAMS_FILENAME
+
+    @old_working_dir = Dir.getwd()
+    @user_dir = Nugrant::Config.user_base_path()
+    @system_dir = Nugrant::Config.system_base_path()
+
+    Dir.chdir(Dir.tmpdir())
+
+    @project_dir = Dir.getwd()
+  end
+
+  def teardown
+    Dir.chdir(@old_working_dir)
+
+    @old_working_dir = nil
+    @project_dir = nil
+    @user_dir = nil
+    @system_dir = nil
+  end
+
+  def test_default_values
+    config = Nugrant::Config.new
+
+    assert_equal(@default_param_filename, config.params_filename())
+    assert_equal("#{@project_dir}/#{@default_param_filename}", config.project_params_path())
+    assert_equal("#{@user_dir}/#{@default_param_filename}", config.user_params_path())
+    assert_equal("#{@system_dir}/#{@default_param_filename}", config.system_params_path())
+  end
+
+  def test_custom_params_filename
+    config = Nugrant::Config.new({:params_filename => ".customparams"})
+
+    assert_equal(".customparams", config.params_filename())
+    assert_equal("#{@project_dir}/.customparams", config.project_params_path())
+    assert_equal("#{@user_dir}/.customparams", config.user_params_path())
+    assert_equal("#{@system_dir}/.customparams", config.system_params_path())
+  end
+
+  def test_custom_params_filename_after_creation
+    config = Nugrant::Config.new({:params_filename => ".vagrantuser"})
+
+    config.params_filename = ".customparams"
+
+    assert_equal(".customparams", config.params_filename())
+    assert_equal("#{@project_dir}/.customparams", config.project_params_path())
+    assert_equal("#{@user_dir}/.customparams", config.user_params_path())
+    assert_equal("#{@system_dir}/.customparams", config.system_params_path())
+  end
+
+  def test_custom_project_params_path
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :project_params_path => "#{@user_dir}/.projectcustomparams"
+    })
+
+    assert_equal(".customparams", config.params_filename())
+    assert_equal("#{@user_dir}/.projectcustomparams", config.project_params_path())
+  end
+
+  def test_custom_user_params_path
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :user_params_path => "#{@system_dir}/.usercustomparams"
+    })
+
+    assert_equal(".customparams", config.params_filename())
+    assert_equal("#{@system_dir}/.usercustomparams", config.user_params_path())  end
+
+  def test_custom_system_params_path
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :system_params_path => "#{@project_dir}/.systemcustomparams"
+    })
+
+    assert_equal(".customparams", config.params_filename())
+    assert_equal("#{@project_dir}/.systemcustomparams", config.system_params_path())
+  end
+
+  def test_custom_all
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :project_params_path => "#{@user_dir}/.projectcustomparams",
+      :user_params_path => "#{@system_dir}/.usercustomparams",
+      :system_params_path => "#{@project_dir}/.systemcustomparams"
+    })
+
+    assert_equal(".customparams", config.params_filename())
+    assert_equal("#{@user_dir}/.projectcustomparams", config.project_params_path())
+    assert_equal("#{@system_dir}/.usercustomparams", config.user_params_path())
+    assert_equal("#{@project_dir}/.systemcustomparams", config.system_params_path())
+  end
+
+  def test_nil_project
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :project_params_path => nil,
+    })
+
+    assert_not_nil("#{@project_dir}/.customparams", config.project_params_path())
+  end
+
+  def test_nil_user
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :user_params_path => nil,
+    })
+
+    assert_equal("#{@user_dir}/.customparams", config.user_params_path())
+  end
+
+  def test_nil_system
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :system_params_path => nil,
+    })
+
+    assert_equal("#{@system_dir}/.customparams", config.system_params_path())
+  end
+end

data/test/lib/nugrant/test_parameters.rb

@@ -0,0 +1,205 @@
+require 'nugrant'
+require 'nugrant/parameters'
+require 'test/unit'
+
+class Nugrant::TestParameters < Test::Unit::TestCase
+
+  @@PARAMS_FILETYPES = ["json", "yml"]
+  @@INVALID_PATH = "impossible_file_path.yml.impossible"
+
+  def create_parameters(params_filetype, project_params_filename, user_params_filename, system_params_filename)
+    resource_path = File.expand_path("#{File.dirname(__FILE__)}/../../resources/#{params_filetype}")
+
+    project_params_path = "#{resource_path}/#{project_params_filename}.#{params_filetype}" if project_params_filename
+    user_params_path = "#{resource_path}/#{user_params_filename}.#{params_filetype}" if user_params_filename
+    system_params_path = "#{resource_path}/#{system_params_filename}.#{params_filetype}" if system_params_filename
+
+    return Nugrant::create_parameters({
+      :params_filetype => params_filetype,
+      :project_params_path => project_params_path,
+      :user_params_path => user_params_path,
+      :system_params_path => system_params_path
+    })
+  end
+
+  def assert_level(parameters, results)
+    results.each do |key, value|
+      assert_equal(value, parameters.send(key), "method(#{key})")
+      assert_equal(value, parameters[key], "array[#{key}]")
+    end
+
+    assert_equal(false, parameters.has_param?("0.0.0"))
+  end
+
+  def test_params_level_1()
+    filetypes.each do |params_filetype|
+      parameters = create_parameters(params_filetype, "params_project_1", "params_user_1", "params_system_1")
+
+      assert_level(parameters, {
+        "1.1.1" => "project",
+        "1.1.0" => "project",
+        "1.0.1" => "project",
+        "0.1.1" => "user",
+        "1.0.0" => "project",
+        "0.1.0" => "user",
+        "0.0.1" => "system",
+      })
+    end
+  end
+
+  def test_params_level_2()
+    filetypes.each do |params_filetype|
+      parameters = create_parameters(params_filetype, "params_project_2", "params_user_2", "params_system_2")
+
+      run_second_level(parameters, "1.1.1", {
+        "1.1.1" => "project",
+        "1.1.0" => "project",
+        "1.0.1" => "project",
+        "0.1.1" => "user",
+        "1.0.0" => "project",
+        "0.1.0" => "user",
+        "0.0.1" => "system",
+      })
+
+      run_second_level(parameters, "1.1.0", {
+        "1.1.1" => "project",
+        "1.1.0" => "project",
+        "1.0.1" => "project",
+        "0.1.1" => "user",
+        "1.0.0" => "project",
+        "0.1.0" => "user",
+      })
+
+      run_second_level(parameters, "1.0.1", {
+        "1.1.1" => "project",
+        "1.1.0" => "project",
+        "1.0.1" => "project",
+        "0.1.1" => "system",
+        "1.0.0" => "project",
+        "0.0.1" => "system",
+      })
+
+      run_second_level(parameters, "0.1.1", {
+        "1.1.1" => "user",
+        "1.1.0" => "user",
+        "1.0.1" => "system",
+        "0.1.1" => "user",
+        "0.1.0" => "user",
+        "0.0.1" => "system",
+      })
+
+      run_second_level(parameters, "1.0.0", {
+        "1.1.1" => "project",
+        "1.1.0" => "project",
+        "1.0.1" => "project",
+        "1.0.0" => "project",
+      })
+
+      run_second_level(parameters, "0.1.0", {
+        "1.1.1" => "user",
+        "1.1.0" => "user",
+        "0.1.1" => "user",
+        "0.1.0" => "user",
+      })
+
+      run_second_level(parameters, "0.0.1", {
+        "1.1.1" => "system",
+        "1.0.1" => "system",
+        "0.1.1" => "system",
+        "0.0.1" => "system",
+      })
+
+      assert_equal(false, parameters.has_param?("0.0.0"))
+    end
+  end
+
+  def run_second_level(parameters, key, results)
+    assert_level(parameters.send(key), results)
+    assert_level(parameters[key], results)
+
+    assert_equal(false, parameters.has_param?("0.0.0"))
+  end
+
+  def test_file_nil()
+    run_test_file_invalid(nil)
+  end
+
+  def test_file_does_not_exist()
+    run_test_file_invalid("impossible_file_path.yml.impossible")
+  end
+
+  def run_test_file_invalid(invalid_value)
+    filetypes.each do |params_filetype|
+      parameters = create_parameters(params_filetype, "params_simple", invalid_path, invalid_path)
+      assert_equal("value", parameters.test)
+      assert_equal("value", parameters["test"])
+
+      parameters = create_parameters(params_filetype, invalid_path, "params_simple", invalid_path)
+      assert_equal("value", parameters.test)
+      assert_equal("value", parameters["test"])
+
+      parameters = create_parameters(params_filetype, invalid_path, invalid_path, "params_simple")
+      assert_equal("value", parameters.test)
+      assert_equal("value", parameters["test"])
+
+      parameters = create_parameters(params_filetype, invalid_path, invalid_path, invalid_path)
+      assert_not_nil(parameters)
+    end
+  end
+
+  def test_params_windows_eol()
+    run_test_params_eol("params_windows_eol")
+  end
+
+  def test_params_unix_eol()
+    run_test_params_eol("params_unix_eol")
+  end
+
+  def run_test_params_eol(file_path)
+    filetypes.each do |params_filetype|
+      parameters = create_parameters(params_filetype, file_path, invalid_path, invalid_path)
+
+      assert_equal("value1", parameters.level1)
+      assert_equal("value2", parameters.level2.first)
+    end
+  end
+
+  def test_restricted_defaults_usage()
+    filetypes.each do |params_filetype|
+      assert_raise(RuntimeError) do
+        results = create_parameters(params_filetype, "params_defaults_at_root", invalid_path, invalid_path)
+        puts("Results: #{results.inspect} (Should have thrown!)")
+      end
+    end
+
+    filetypes.each do |params_filetype|
+      assert_raise(RuntimeError) do
+        results = create_parameters(params_filetype, "params_defaults_not_at_root", invalid_path, invalid_path)
+        puts("Results: #{results.inspect} (Should have thrown!)")
+      end
+    end
+  end
+
+  def test_defaults()
+    filetypes.each do |params_filetype|
+      parameters = create_parameters(params_filetype, "params_simple", invalid_path, invalid_path)
+      parameters.defaults({"test" => "override", "level" => "new"})
+
+      assert_equal("value", parameters.test)
+      assert_equal("new", parameters.level)
+
+      parameters.defaults = {"test" => "override1", "level" => "new1"}
+
+      assert_equal("value", parameters.test)
+      assert_equal("new1", parameters.level)
+    end
+  end
+
+  def filetypes()
+    @@PARAMS_FILETYPES
+  end
+
+  def invalid_path()
+    @@INVALID_PATH
+  end
+end