vagrant-triggers 0.4.4 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 82d8d42ba2873b8ff1d16d07b4415c7b408c0cfa
-  data.tar.gz: 393eaa0899b5e070d5e8bcec79da77f1f19bd92b
+  metadata.gz: feda77ab141c553c1886766fd74d69ddfb0b2153
+  data.tar.gz: 0b73b4f744e7f5c0aec0a769eaa90629076c2c98
 SHA512:
-  metadata.gz: 56647d8624db454ebb33e9c46a1e0199e7c38e9e818f7d88ce371aaf83e295e6a70a26b5ecb5e4d9cd224679ede171b7f7206d6cf781f39a3ea7382b3900ca49
-  data.tar.gz: 2e4fea84758569ce2a2e114e0555922678223ae2bb8832768aef71bf8fd01e24bdb6c442fee84f0371a3dc6e610d970b76a77b457adde560f56dbe3d917d1f31
+  metadata.gz: 5ec60cd4c036eaedf2f64d9f5e63559d00dfc39d7a29eab6cd7e38b4de3a1d9d5acb4d0dc65d8ad02c2e5767d5c69c9ce22bacb610cf609084466edcad85a491
+  data.tar.gz: 8d05d7c3abf88ccabc6a93b2542183a36bfdfe9d7aea0abdba3e41c2fbfc047e8a3fbab2eafc61af1fc06165cdb2fc35a37978fcdaab5307bc9a2b0e7f80f370

data/.gitignore

@@ -3,6 +3,8 @@
 .bundle
 pkg/*
 Gemfile.lock
+Gemfile.dev
+Gemfile.dev.lock
 
 coverage
 

data/.travis.yml

@@ -7,11 +7,13 @@ before_install:
   - gem uninstall -ax bundler
   - gem install bundler -v 1.5.3
 env:
-  - VAGRANT_VERSION=v1.6.5
+  - VAGRANT_VERSION=v1.7.1
 matrix:
   include:
     - env: VAGRANT_VERSION=master
       rvm: 2.0.0
+    - env: VAGRANT_VERSION=v1.6.5
+      rvm: 2.0.0
     - env: VAGRANT_VERSION=v1.5.4
       rvm: 2.0.0
     - env: VAGRANT_VERSION=v1.4.3
@@ -23,3 +25,4 @@ matrix:
   allow_failures:
     - env: VAGRANT_VERSION=master
       rvm: 2.0.0
+sudo: false

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## 0.5.0 (December 29, 2014)
+
+**BEHAVIOURAL CHANGES:**
+
+  - The ```:stdout``` option now defaults to true.
+
+NEW FEATURES:
+
+  - New option ```:stderr``` for displaying standard error from scripts.
+  - The special action ```:ALL``` can be used when a trigger should always run [(#23)](https://github.com/emyl/vagrant-triggers/issues/23)
+  - Actions can be blacklisted using ```config.trigger.blacklist```.
+  - Triggers can be run as a provisioner [(#21)](https://github.com/emyl/vagrant-triggers/issues/21)
+
+IMPROVEMENTS:
+
+  - Do not buffer command output and better integrate in core UI [(#18)](https://github.com/emyl/vagrant-triggers/issues/18)
+
+BUG FIXES:
+
+  - Handle MS-DOS commands better [(#27)](https://github.com/emyl/vagrant-triggers/issues/27)
+
 ## 0.4.4 (December 12, 2014)
 
 BUG FIXES:

data/README.md

@@ -43,11 +43,27 @@ The ```instead_of``` trigger could also be aliased as ```reject```.
 
 The first argument is the command in which the trigger will be tied. It could be an array (e.g. ```[:up, :resume]```) in case of multiple commands.
 
+Starting from version 0.5.0, triggers can also be run as a provisioner:
+
+```ruby
+Vagrant.configure("2") do |config|
+  # Your existing Vagrant configuration
+  ...
+
+  config.vm.provision "trigger", :option => "value" do |trigger|
+    trigger.fire do
+      run "script"
+    end
+  end
+end
+```
+
 ### Options
 
 * ```:append_to_path => ["dir", "dir"]```: additional places where looking for scripts. See [this wiki page](https://github.com/emyl/vagrant-triggers/wiki/The-:append_to_path-option) for details.
-* ```:force => true```: continue even if one of the scripts fails (exits with non-zero code)
-* ```:stdout => true```: display script output
+* ```:force => true|false```: continue even if one of the scripts fails (exits with non-zero code). Defaults to false.
+* ```:stderr => true|false```: display standard error from scripts. Defaults to true.
+* ```:stdout => true|false```: display standard output from scripts. Defaults to true.
 * ```:vm => ["vm1", /vm[2-3]/]```: fire only for matching virtual machines. Value can be a string, a regexp or an array of strings and/or regexps.
 
 ### Trigger block DSL
@@ -109,6 +125,3 @@ To run the plugin's tests:
     $ bundle exec rake
 
 You can now fork this repository, make your changes and send a pull request.
-
-
-[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/emyl/vagrant-triggers/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

data/lib/vagrant-triggers.rb

@@ -4,10 +4,11 @@ require "vagrant-triggers/plugin"
 module VagrantPlugins
   module Triggers
     lib_path = Pathname.new(File.expand_path("../vagrant-triggers", __FILE__))
-    autoload :Action,   lib_path.join("action")
-    autoload :DSL,      lib_path.join("dsl")
-    autoload :Config,   lib_path.join("config")
-    autoload :Errors,   lib_path.join("errors")
+    autoload :Action,      lib_path.join("action")
+    autoload :DSL,         lib_path.join("dsl")
+    autoload :Config,      lib_path.join("config")
+    autoload :Errors,      lib_path.join("errors")
+    autoload :Provisioner, lib_path.join("provisioner")
 
     # This returns the path to the source of this plugin.
     #

data/lib/vagrant-triggers/action/trigger.rb

@@ -31,18 +31,13 @@ module VagrantPlugins
           trigger_env.each { |k, v| @logger.debug("-- #{k}: #{v}")}
 
           # Loop through all defined triggers checking for matches.
+          triggers_config  = @env[:machine].config.trigger
           triggers_to_fire = [].tap do |triggers|
-            @env[:machine].config.trigger.triggers.each do |trigger|
-              next if trigger[:action]    != trigger_env[:action]
+            triggers_config.triggers.each do |trigger|
+              next if trigger[:action] != :ALL && trigger[:action] != trigger_env[:action]
               next if trigger[:condition] != trigger_env[:condition]
 
-              if trigger[:options][:vm]
-                match = false
-                Array(trigger[:options][:vm]).each do |pattern|
-                  match = true if trigger_env[:vm].match(Regexp.new(pattern))
-                end
-                next unless match
-              end
+              next if triggers_config.blacklist.include?(trigger_env[:action])
 
               triggers << trigger
             end
@@ -55,8 +50,11 @@ module VagrantPlugins
 
           triggers_to_fire.each do |trigger|
             if trigger[:proc]
-              dsl = DSL.new(@env[:ui], @env[:machine], trigger[:options])
-              dsl.instance_eval &trigger[:proc]
+              begin
+                dsl = DSL.new(@env[:machine], trigger[:options])
+                dsl.instance_eval &trigger[:proc]
+              rescue Errors::NotMatchingMachine
+              end
             else
               @logger.debug("Trigger command not found.")
             end

data/lib/vagrant-triggers/config.rb

@@ -1,48 +1,10 @@
 module VagrantPlugins
   module Triggers
-    class Config < Vagrant.plugin("2", :config)
-      attr_reader :triggers
-
-      def initialize
-        @triggers = []
-      end
-
-      def after(actions, options = {}, &block)
-        add_trigger(actions, :after, options, block)
-      end
-
-      def before(actions, options = {}, &block)
-        add_trigger(actions, :before, options, block)
-      end
-
-      def instead_of(actions, options = {}, &block)
-        add_trigger(actions, :instead_of, options, block)
-      end
-      alias_method :reject, :instead_of
-
-      def merge(other)
-        super.tap do |result|
-          result.instance_variable_set(:@triggers, @triggers + other.triggers)
-        end
-      end
-
-      def validate(machine)
-        errors = []
-
-        if @__invalid_methods && !@__invalid_methods.empty?
-          errors << I18n.t("vagrant.config.common.bad_field", :fields => @__invalid_methods.to_a.sort.join(", "))
-        end
-
-        { "triggers" => errors }
-      end
-
-      private
-
-      def add_trigger(actions, condition, options, proc)
-        Array(actions).each do |action|
-          @triggers << { :action => action, :condition => condition, :options => options, :proc => proc }
-        end
-      end
+    module Config
+      # Autoload farm
+      config_root = Pathname.new(File.expand_path("../config", __FILE__))
+      autoload :Provisioner, config_root.join("provisioner")
+      autoload :Trigger,     config_root.join("trigger")
     end
   end
 end

data/lib/vagrant-triggers/config/provisioner.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module Triggers
+    module Config
+      class Provisioner < Vagrant.plugin("2", :config)
+        attr_reader :options
+        attr_reader :trigger_body
+
+        def initialize
+          @options = {}
+        end
+
+        def fire(&block)
+          @trigger_body = block
+        end
+
+        def set_options(options)
+          @options = options
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-triggers/config/trigger.rb

@@ -0,0 +1,61 @@
+module VagrantPlugins
+  module Triggers
+    module Config
+      class Trigger < Vagrant.plugin("2", :config)
+        attr_reader :triggers
+
+        def initialize
+          @blacklist = []
+          @options   = { :stdout => true, :stderr => true }
+          @triggers  = []
+        end
+
+        def after(actions, options = {}, &block)
+          add_trigger(actions, :after, options, block)
+        end
+
+        def before(actions, options = {}, &block)
+          add_trigger(actions, :before, options, block)
+        end
+
+        def blacklist(actions = nil)
+          if actions
+            Array(actions).each { |action| @blacklist << action.to_s }
+            @blacklist.uniq!
+          end
+          @blacklist
+        end
+
+        def instead_of(actions, options = {}, &block)
+          add_trigger(actions, :instead_of, options, block)
+        end
+        alias_method :reject, :instead_of
+
+        def merge(other)
+          super.tap do |result|
+            result.instance_variable_set(:@blacklist, @blacklist + other.blacklist)
+            result.instance_variable_set(:@triggers, @triggers + other.triggers)
+          end
+        end
+
+        def validate(machine)
+          errors = []
+
+          if @__invalid_methods && !@__invalid_methods.empty?
+            errors << I18n.t("vagrant.config.common.bad_field", :fields => @__invalid_methods.to_a.sort.join(", "))
+          end
+
+          { "triggers" => errors }
+        end
+
+        private
+
+        def add_trigger(actions, condition, options, proc)
+          Array(actions).each do |action|
+            @triggers << { :action => action, :condition => condition, :options => @options.merge(options), :proc => proc }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-triggers/dsl.rb

@@ -1,16 +1,30 @@
 require "bundler"
 require "log4r"
-require "shellwords"
 require "vagrant/util/subprocess"
 
 module VagrantPlugins
   module Triggers
     class DSL
-      def initialize(ui, machine, options = {})
+      def initialize(machine, options = {})
+        if options[:vm]
+          match = false
+          Array(options[:vm]).each do |pattern|
+            match = true if machine.name.match(Regexp.new(pattern))
+          end
+          raise Errors::NotMatchingMachine unless match
+        end
+
+        @buffer  = Hash.new("")
         @logger  = Log4r::Logger.new("vagrant::plugins::triggers::dsl")
         @machine = machine
         @options = options
-        @ui      = ui
+        @ui      = machine.ui
+
+        @command_output = lambda do |channel, data, options|
+          ui_method = (channel == :stdout) ? :info : :error
+          @buffer[channel] += data
+          @ui.send(ui_method, data) if options[channel]
+        end
       end
 
       def error(message, *opts)
@@ -18,36 +32,38 @@ module VagrantPlugins
       end
 
       def run(raw_command, options = {})
-        info I18n.t("vagrant_triggers.action.trigger.executing_command", :command => raw_command)
-        command    = Shellwords.shellsplit(raw_command)
+        command = shellsplit(raw_command)
+        options.merge!(@options) { |key, old, new| old }
+        info I18n.t("vagrant_triggers.action.trigger.executing_command", :command => command.join(" "))
         env_backup = ENV.to_hash
         begin
           result = nil
           Bundler.with_clean_env do
             build_environment
-            result = Vagrant::Util::Subprocess.execute(command[0], *command[1..-1])
+            @buffer.clear
+            result = Vagrant::Util::Subprocess.execute(command[0], *command[1..-1], :notify => [:stdout, :stderr]) do |channel, data|
+              @command_output.call(channel, data, options)
+            end
           end
+          info I18n.t("vagrant_triggers.action.trigger.command_finished")
         rescue Vagrant::Errors::CommandUnavailable, Vagrant::Errors::CommandUnavailableWindows
           raise Errors::CommandUnavailable, :command => command[0]
         ensure
           ENV.replace(env_backup)
         end
-        process_result(raw_command, result, @options.merge(options))
+        process_result(raw_command, result, options)
       end
       alias_method :execute, :run
 
       def run_remote(raw_command, options = {})
+        options.merge!(@options) { |key, old, new| old }
         info I18n.t("vagrant_triggers.action.trigger.executing_remote_command", :command => raw_command)
-        stderr = ""
-        stdout = ""
-        exit_code = @machine.communicate.sudo(raw_command, :elevated => true, :good_exit => (0..255).to_a) do |type, data|
-          if type == :stderr
-            stderr += data
-          elsif type == :stdout
-            stdout += data
-          end
+        @buffer.clear
+        exit_code = @machine.communicate.sudo(raw_command, :elevated => true, :good_exit => (0..255).to_a) do |channel, data|
+          @command_output.call(channel, data, options)
         end
-        process_result(raw_command, Vagrant::Util::Subprocess::Result.new(exit_code, stdout, stderr), @options.merge(options))
+        info I18n.t("vagrant_triggers.action.trigger.remote_command_finished")
+        process_result(raw_command, Vagrant::Util::Subprocess::Result.new(exit_code, @buffer[:stdout], @buffer[:stderr]), options)
       end
       alias_method :execute_remote, :run_remote
 
@@ -84,11 +100,27 @@ module VagrantPlugins
         if result.exit_code != 0 && !options[:force]
           raise Errors::CommandFailed, :command => command, :stderr => result.stderr
         end
-        if options[:stdout]
-          info I18n.t("vagrant_triggers.action.trigger.command_output", :output => result.stdout)
-        end
         result.stdout
       end
+
+      # This is a custom version of Shellwords.shellsplit adapted for handling MS-DOS commands.
+      #
+      # Basically escape sequences are left intact if the platform is Windows.
+      def shellsplit(line)
+        words = []
+        field = ''
+        line.scan(/\G\s*(?>([^\s\\\'\"]+)|'([^\']*)'|"((?:[^\"\\]|\\.)*)"|(\\.?)|(\S))(\s|\z)?/) do |word, sq, dq, esc, garbage, sep|
+          raise ArgumentError, "Unmatched double quote: #{line.inspect}" if garbage
+          token = (word || sq || (dq || esc))
+          token.gsub!(/\\(.)/, '\1') unless Vagrant::Util::Platform.windows?
+          field << token
+          if sep
+            words << field
+            field = ''
+          end
+        end
+        words
+      end
     end
   end
 end

data/lib/vagrant-triggers/errors.rb

@@ -16,6 +16,9 @@ module VagrantPlugins
       class DSLError < VagrantTriggerError
         error_key(:dsl_error)
       end
+
+      class NotMatchingMachine < VagrantTriggerError
+      end
     end
   end
 end

data/lib/vagrant-triggers/plugin.rb

@@ -34,12 +34,22 @@ module VagrantPlugins
       end
 
       config(:trigger) do
-        require_relative "config"
-        Config
+        require_relative "config/trigger"
+        Config::Trigger
+      end
+
+      config(:trigger, :provisioner) do
+        require_relative "config/provisioner"
+        Config::Provisioner
+      end
+
+      provisioner(:trigger) do
+        require_relative "provisioner"
+        Provisioner
       end
 
       # This initializes the I18n load path so that the plugin specific
-      # transations work.
+      # translations work.
       def self.init_i18n
         I18n.load_path << File.expand_path("locales/en.yml", Triggers.source_root)
         I18n.reload!

data/lib/vagrant-triggers/provisioner.rb

@@ -0,0 +1,26 @@
+module VagrantPlugins
+  module Triggers
+    class Provisioner < Vagrant.plugin("2", :provisioner)
+      def initialize(machine, config)
+        @config  = config
+        begin
+          @dsl = DSL.new(machine, @config.options)
+        rescue Errors::NotMatchingMachine
+          ENV["VAGRANT_NO_TRIGGERS"] = "1"
+        end
+      end
+
+      def configure(root_config)
+      end
+
+      def provision
+        unless ENV["VAGRANT_NO_TRIGGERS"]
+          @dsl.instance_eval &@config.trigger_body
+        end
+      end
+
+      def cleanup
+      end
+    end
+  end
+end

data/lib/vagrant-triggers/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Triggers
-    VERSION = "0.4.4"
+    VERSION = "0.5.0"
   end
 end

data/locales/en.yml

@@ -2,15 +2,14 @@ en:
   vagrant_triggers:
     action:
       trigger:
-        command_output: |-
-          Command output:
-          ---------------
-          %{output}
-          ---------------
+        command_finished: |-
+          Command execution finished.
         executing_command: |-
           Executing command "%{command}"...
         executing_remote_command: |-
           Executing remote command "%{command}"...
+        remote_command_finished: |-
+          Remote command execution finished.
         running_triggers: |-
           Running triggers %{condition} %{action}...
     errors:

data/spec/spec_helper.rb

@@ -5,3 +5,9 @@ require "vagrant"
 require_relative "../lib/vagrant-triggers"
 
 VagrantPlugins::Triggers::Plugin.init_i18n
+
+RSpec.configure do |config|
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :should
+  end
+end

data/spec/vagrant-triggers/action/trigger_spec.rb

@@ -5,16 +5,17 @@ describe VagrantPlugins::Triggers::Action::Trigger do
   let(:env)            { { :action_name => action_name, :machine => machine, :machine_action => machine_action, :ui => ui } }
   let(:condition)      { double("condition") }
   let(:action_name)    { double("action_name") }
-  let(:machine)        { double("machine") }
+  let(:machine)        { double("machine", :ui => ui) }
   let(:machine_action) { double("machine_action") }
 
   let(:ui)             { double("ui", :info => info) }
   let(:info)           { double("info") }
 
-  before do
+  before :each do
     trigger_block = Proc.new { nil }
     @triggers     = [ { :action => machine_action, :condition => condition, :options => { }, :proc => trigger_block } ]
     machine.stub(:name)
+    machine.stub_chain(:config, :trigger, :blacklist).and_return([])
     machine.stub_chain(:config, :trigger, :triggers).and_return(@triggers)
   end
 
@@ -35,7 +36,15 @@ describe VagrantPlugins::Triggers::Action::Trigger do
 
   it "should fire trigger when all conditions are satisfied" do
     dsl = double("dsl")
-    VagrantPlugins::Triggers::DSL.stub(:new).with(ui, machine, @triggers.first[:options]).and_return(dsl)
+    VagrantPlugins::Triggers::DSL.stub(:new).with(machine, @triggers.first[:options]).and_return(dsl)
+    dsl.should_receive(:instance_eval).and_yield
+    described_class.new(app, env, condition).call(env)
+  end
+
+  it "should fire trigger when condition matches and action is :ALL" do
+    @triggers[0][:action] = :ALL
+    dsl = double("dsl")
+    VagrantPlugins::Triggers::DSL.stub(:new).with(machine, @triggers.first[:options]).and_return(dsl)
     dsl.should_receive(:instance_eval).and_yield
     described_class.new(app, env, condition).call(env)
   end
@@ -52,14 +61,20 @@ describe VagrantPlugins::Triggers::Action::Trigger do
     described_class.new(app, env, condition).call(env)
   end
 
+  it "shouldn't fire trigger when the action is blacklisted" do
+    machine.stub_chain(:config, :trigger, :blacklist).and_return([machine_action])
+    VagrantPlugins::Triggers::DSL.should_not_receive(:new)
+    described_class.new(app, env, condition).call(env)
+  end
+
   it "shouldn't fire trigger when condition doesn't match" do
-    @triggers[0][:condition] = "blah"
+    @triggers[0][:condition] = :blah
     VagrantPlugins::Triggers::DSL.should_not_receive(:new)
     described_class.new(app, env, condition).call(env)
   end
 
   it "shouldn't fire trigger when action doesn't match" do
-    @triggers[0][:action] = "blah"
+    @triggers[0][:action] = :blah
     VagrantPlugins::Triggers::DSL.should_not_receive(:new)
     described_class.new(app, env, condition).call(env)
   end
@@ -70,45 +85,8 @@ describe VagrantPlugins::Triggers::Action::Trigger do
     described_class.new(app, env, :instead_of).call(env)
   end
 
-  context ":vm option" do
-    before do
-      machine.stub(:name).and_return(:vm1)
-    end
-
-    it "should fire trigger when :vm option match" do
-      @triggers[0][:options][:vm] = "vm1"
-      VagrantPlugins::Triggers::DSL.should_receive(:new)
-      described_class.new(app, env, condition).call(env)
-    end
-
-    it "shouldn't fire trigger when :vm option doesn't match" do
-      @triggers[0][:options][:vm] = "vm2"
-      VagrantPlugins::Triggers::DSL.should_not_receive(:new)
-      described_class.new(app, env, condition).call(env)
-    end
-
-    it "should fire trigger when :vm option is an array and one of the elements match" do
-      @triggers[0][:options][:vm] = ["vm1", "vm2"]
-      VagrantPlugins::Triggers::DSL.should_receive(:new)
-      described_class.new(app, env, condition).call(env)
-    end
-
-    it "shouldn't fire trigger when :vm option is an array and no element match" do
-      @triggers[0][:options][:vm] = ["vm2", "vm3"]
-      VagrantPlugins::Triggers::DSL.should_not_receive(:new)
-      described_class.new(app, env, condition).call(env)
-    end
-
-    it "should fire trigger when :vm option is a regex and the pattern match" do
-      @triggers[0][:options][:vm] = /^vm/
-      VagrantPlugins::Triggers::DSL.should_receive(:new)
-      described_class.new(app, env, condition).call(env)
-    end
-
-    it "shouldn't fire trigger when :vm option is a regex and the pattern doesn't match" do
-      @triggers[0][:options][:vm] = /staging/
-      VagrantPlugins::Triggers::DSL.should_not_receive(:new)
-      described_class.new(app, env, condition).call(env)
-    end
+  it "should handle gracefully a not matching :vm option" do
+    VagrantPlugins::Triggers::DSL.stub(:new).and_raise(VagrantPlugins::Triggers::Errors::NotMatchingMachine)
+    expect { described_class.new(app, env, condition).call(env) }.not_to raise_exception()
   end
 end

data/spec/vagrant-triggers/config/provisioner_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe VagrantPlugins::Triggers::Config::Provisioner do
+  let(:config)  { described_class.new }
+
+  describe "fire" do
+    it "should record trigger code" do
+      code = Proc.new { "foo" }
+      config.fire(&code)
+      expect(config.trigger_body).to eq(code)
+    end
+  end
+
+  describe "set_options" do
+    it "should set options" do
+      options = { :foo => "bar", :baz => "bat" }
+      config.set_options(options)
+      expect(config.options).to eq(options)
+    end
+  end
+end

data/spec/vagrant-triggers/config/trigger_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+describe VagrantPlugins::Triggers::Config::Trigger do
+  let(:config)  { described_class.new }
+  let(:machine) { double("machine") }
+
+  describe "defaults" do
+    subject do
+      config.tap do |o|
+        o.finalize!
+      end
+      expect(config.triggers).to eq([])
+    end
+
+    it "should default :stdout option to true" do
+      config.before(:up) { run "ls" }
+      expect(config.triggers.first[:options][:stdout]).to eq(true)
+    end
+
+    it "should default :stderr option to true" do
+      config.before(:up) { run "ls" }
+      expect(config.triggers.first[:options][:stderr]).to eq(true)
+    end
+
+    it "should override options" do
+      config.before(:up, :stdout => false) { run "ls" }
+      expect(config.triggers.first[:options][:stdout]).to eq(false)
+    end
+  end
+
+  describe "add triggers" do
+    it "should add before triggers" do
+      config.before(:up) { run "ls" }
+      expect(config.triggers.size).to eq(1)
+    end
+
+    it "should add instead_of triggers" do
+      config.instead_of(:up) { run "ls" }
+      expect(config.triggers.size).to eq(1)
+    end
+
+    it "should add after triggers" do
+      config.after(:up) { run "ls" }
+      expect(config.triggers.size).to eq(1)
+    end
+  end
+
+  describe "blacklist" do
+    it "should blacklist an action" do
+      config.blacklist(:up)
+      expect(config.blacklist.size).to eq(1)
+    end
+
+    it "should blacklist multiple actions" do
+      config.blacklist([:up, :destroy])
+      expect(config.blacklist.size).to eq(2)
+    end
+
+    it "should convert symbols to strings" do
+      config.blacklist(:up)
+      expect(config.blacklist).to eq(["up"])
+    end
+
+    it "should blacklist an action only once" do
+      config.blacklist(["up", "destroy"])
+      config.blacklist(:up)
+      expect(config.blacklist).to eq(["up", "destroy"])
+    end
+  end
+
+  describe "accept multiple entries" do
+    it "should record multiple entries" do
+      config.before(:up) { run "ls" }
+      config.after(:up) { run "ls" }
+      expect(config.triggers.size).to eq(2)
+    end
+
+    it "should record multiple entries if the action is an array" do
+      config.before([:up, :halt]) { run "ls" }
+      expect(config.triggers.size).to eq(2)
+    end
+  end
+
+  describe "validation" do
+    it "should validate" do
+      config.finalize!
+      expect(config.validate(machine)["triggers"].size).to eq(0)
+    end
+
+    it "shouldn't accept invalid methods" do
+      config.foo "bar"
+      expect(config.validate(machine)["triggers"].size).to eq(1)
+    end
+  end
+end

data/spec/vagrant-triggers/dsl_spec.rb

@@ -5,17 +5,53 @@ describe VagrantPlugins::Triggers::DSL do
   let(:result) { double("result", :exit_code => 0, :stderr => stderr) }
   let(:stderr) { double("stderr") }
 
-  let(:machine) { double("machine") }
+  let(:machine) { double("machine", :ui => ui) }
   let(:ui)      { double("ui", :info => info) }
   let(:info)    { double("info") }
 
   before do
     @command = "foo"
-    @dsl     = described_class.new(ui, machine, {})
+    @dsl     = described_class.new(machine, {})
 
     result.stub(:stdout => "Some output")
   end
 
+  context ":vm option" do
+    before do
+      machine.stub(:name => :vm1)
+    end
+
+    it "should raise no exception when :vm option match" do
+      options = { :vm => "vm1" }
+      expect { described_class.new(machine, options) }.not_to raise_error()
+    end
+
+    it "should raise NotMatchingMachine when :vm option doesn't match" do
+      options = { :vm => "vm2" }
+      expect { described_class.new(machine, options) }.to raise_error(VagrantPlugins::Triggers::Errors::NotMatchingMachine)
+    end
+
+    it "should raise no exception when :vm option is an array and one of the elements match" do
+      options = { :vm => ["vm1", "vm2"] }
+      expect { described_class.new(machine, options) }.not_to raise_error()
+    end
+
+    it "should raise NotMatchingMachine when :vm option is an array and no element match" do
+      options = { :vm => ["vm2", "vm3"] }
+      expect { described_class.new(machine, options) }.to raise_error(VagrantPlugins::Triggers::Errors::NotMatchingMachine)
+    end
+
+    it "should raise no exception when :vm option is a regex and the pattern match" do
+      options = { :vm => /^vm/ }
+      expect { described_class.new(machine, options) }.not_to raise_error()
+    end
+
+    it "should raise NotMatchingMachine when :vm option is a regex and the pattern doesn't match" do
+      options = { :vm => /staging/ }
+      expect { described_class.new(machine, options) }.to raise_error(VagrantPlugins::Triggers::Errors::NotMatchingMachine)
+    end
+  end
+
   context "error" do
     it "should raise a DSL error on UI error" do
       ui.should_receive(:error).with("Error message")
@@ -33,6 +69,7 @@ describe VagrantPlugins::Triggers::DSL do
   context "run a regular command" do
     before do
       Vagrant::Util::Subprocess.stub(:execute => result)
+      @options = { :notify => [:stdout, :stderr] }
     end
 
     it "should raise an error if executed command exits with non-zero code" do
@@ -41,15 +78,14 @@ describe VagrantPlugins::Triggers::DSL do
     end
 
     it "shouldn't raise an error if executed command exits with non-zero code but :force option was specified" do
-      dsl = described_class.new(ui, machine, :force => true)
+      dsl = described_class.new(machine, :force => true)
       result.stub(:exit_code => 1)
       expect { dsl.run(@command) }.not_to raise_error()
     end
 
-    it "should display output if :stdout option was specified" do
-      dsl = described_class.new(ui, machine, :stdout => true)
-      ui.should_receive(:info).with(/Some output/)
-      dsl.run(@command)
+    it "should return standard output" do
+      dsl = described_class.new(machine)
+      expect(dsl.run(@command)).to eq("Some output")
     end
 
     it "should pass VAGRANT_NO_TRIGGERS environment variable to the command" do
@@ -59,6 +95,19 @@ describe VagrantPlugins::Triggers::DSL do
       end
       @dsl.run(@command)
     end
+
+    it "should remove escape sequences on UNIX Bourne Shell" do
+      command = "echo foo\\ bar"
+      Vagrant::Util::Subprocess.should_receive(:execute).with("echo", "foo bar", @options)
+      @dsl.run(command)
+    end
+
+    it "should not remove escape sequences on MS-DOS Shell" do
+      Vagrant::Util::Platform.stub(:windows? => true)
+      command = "echo foo\\ bar"
+      Vagrant::Util::Subprocess.should_receive(:execute).with("echo", "foo\\ bar", @options)
+      @dsl.run(command)
+    end
   end
 
   context "run a command not in the PATH" do
@@ -83,14 +132,14 @@ describe VagrantPlugins::Triggers::DSL do
     end
 
     it "should honor the :append_to_path option and restore original path after execution" do
-      dsl = described_class.new(ui, machine, :append_to_path => @tmp_dir)
+      dsl = described_class.new(machine, :append_to_path => @tmp_dir)
       original_path = ENV["PATH"]
       dsl.run(@command)
       expect(ENV["PATH"]).to eq(original_path)
     end
 
     it "should accept an array for the :append_to_path option" do
-      dsl = described_class.new(ui, machine, :append_to_path => [@tmp_dir, @tmp_dir])
+      dsl = described_class.new(machine, :append_to_path => [@tmp_dir, @tmp_dir])
       expect { dsl.run(@command) }.not_to raise_error()
     end
   end
@@ -162,15 +211,14 @@ describe VagrantPlugins::Triggers::DSL do
     end
 
     it "shouldn't raise an error if executed command exits with non-zero code but :force option was specified" do
-      dsl = described_class.new(ui, machine, :force => true)
+      dsl = described_class.new(machine, :force => true)
       result.stub(:exit_code => 1)
       expect { dsl.run_remote(@command) }.not_to raise_error()
     end
 
-    it "should display output if :stdout option was specified" do
-      dsl = described_class.new(ui, machine, :stdout => true)
-      ui.should_receive(:info).with(/Some output/)
-      dsl.run_remote(@command)
+    it "should return standard output" do
+      dsl = described_class.new(machine)
+      expect(dsl.run_remote(@command)).to eq("Some output")
     end
   end
 end

data/spec/vagrant-triggers/provisioner_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe VagrantPlugins::Triggers::Provisioner do
+  let(:config)  { double("config", :options => options, :trigger_body => Proc.new { "foo" }) }
+  let(:machine) { double("machine") }
+  let(:options) { double("options") }
+
+  before :each do
+    ENV["VAGRANT_NO_TRIGGERS"] = nil
+  end
+
+  describe "constructor" do
+    it "should create a DSL object" do
+      VagrantPlugins::Triggers::DSL.should_receive(:new).with(machine, options)
+      described_class.new(machine, config)
+    end
+
+    it "should handle gracefully a not matching :vm option" do
+      VagrantPlugins::Triggers::DSL.stub(:new).and_raise(VagrantPlugins::Triggers::Errors::NotMatchingMachine)
+      expect { described_class.new(machine, config) }.not_to raise_exception()
+    end
+  end
+
+  describe "provision" do
+    before :each do
+      @dsl = double("dsl")
+      VagrantPlugins::Triggers::DSL.stub(:new).with(machine, options).and_return(@dsl)
+    end
+
+    it "should run code against DSL object" do
+      @dsl.should_receive(:instance_eval).and_yield
+      described_class.new(machine, config).provision
+    end
+
+    it "should not run code if VAGRANT_NO_TRIGGERS is set" do
+      ENV["VAGRANT_NO_TRIGGERS"] = "1"
+      @dsl.should_not_receive(:instance_eval)
+      described_class.new(machine, config).provision
+    end
+  end
+end

data/vagrant-triggers.gemspec

@@ -51,5 +51,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "bundler", "~> 1.3"
 
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "< 3"
+  spec.add_development_dependency "rspec"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-triggers
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.0
 platform: ruby
 authors:
 - Emiliano Ticci
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-12 00:00:00.000000000 Z
+date: 2014-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -42,16 +42,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - <
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - <
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '0'
 description: This plugin allow the definition of arbitrary scripts that will run on
   the host before and/or after Vagrant commands.
 email: emiticci@gmail.com
@@ -63,10 +63,13 @@ files:
 - Gemfile
 - lib/vagrant-triggers/action/trigger.rb
 - lib/vagrant-triggers/action.rb
+- lib/vagrant-triggers/config/provisioner.rb
+- lib/vagrant-triggers/config/trigger.rb
 - lib/vagrant-triggers/config.rb
 - lib/vagrant-triggers/dsl.rb
 - lib/vagrant-triggers/errors.rb
 - lib/vagrant-triggers/plugin.rb
+- lib/vagrant-triggers/provisioner.rb
 - lib/vagrant-triggers/version.rb
 - lib/vagrant-triggers.rb
 - LICENSE.txt
@@ -75,8 +78,10 @@ files:
 - README.md
 - spec/spec_helper.rb
 - spec/vagrant-triggers/action/trigger_spec.rb
-- spec/vagrant-triggers/config_spec.rb
+- spec/vagrant-triggers/config/provisioner_spec.rb
+- spec/vagrant-triggers/config/trigger_spec.rb
 - spec/vagrant-triggers/dsl_spec.rb
+- spec/vagrant-triggers/provisioner_spec.rb
 - spec/vagrant-triggers/vagrant_spec.rb
 - vagrant-triggers.gemspec
 - .gitignore
@@ -108,6 +113,8 @@ summary: Triggers for Vagrant commands.
 test_files:
 - spec/spec_helper.rb
 - spec/vagrant-triggers/action/trigger_spec.rb
-- spec/vagrant-triggers/config_spec.rb
+- spec/vagrant-triggers/config/provisioner_spec.rb
+- spec/vagrant-triggers/config/trigger_spec.rb
 - spec/vagrant-triggers/dsl_spec.rb
+- spec/vagrant-triggers/provisioner_spec.rb
 - spec/vagrant-triggers/vagrant_spec.rb

data/spec/vagrant-triggers/config_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-
-describe VagrantPlugins::Triggers::Config do
-  let(:config)  { described_class.new }
-  let(:machine) { double("machine") }
-
-  describe "defaults" do
-    subject do
-      config.tap do |o|
-        o.finalize!
-      end
-    end
-
-    its("triggers") { should eq [] }
-  end
-
-  describe "add triggers" do
-    it "should add before triggers" do
-      config.before(:up) { run "ls" }
-      expect(config.triggers).to have(1).item
-    end
-
-    it "should add instead_of triggers" do
-      config.instead_of(:up) { run "ls" }
-      expect(config.triggers).to have(1).item
-    end
-
-    it "should add after triggers" do
-      config.after(:up) { run "ls" }
-      expect(config.triggers).to have(1).item
-    end
-  end
-
-  describe "accept multiple entries" do
-    it "should record multiple entries" do
-      config.before(:up) { run "ls" }
-      config.after(:up) { run "ls" }
-      expect(config.triggers).to have(2).items
-    end
-
-    it "should record multiple entries if the action is an array" do
-      config.before([:up, :halt]) { run "ls" }
-      expect(config.triggers).to have(2).items
-    end
-  end
-
-  describe "validation" do
-    it "should validate" do
-      config.finalize!
-      expect(config.validate(machine)["triggers"]).to have(:no).items
-    end
-
-    it "shouldn't accept invalid methods" do
-      config.foo "bar"
-      expect(config.validate(machine)["triggers"]).to have(1).item
-    end
-  end
-end