singularity_dsl 2.2.2 → 3.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZTYwMDQ2MDU3YjIwYjZjMWY3YzRmNTAyOGE0ZjNkZDIzMjJjYTVlZg==
+    NzcwOGJhZDM1OTA0YjZhM2QxOGVkMjdlNDAzOGY2YTFhOWVhMDUxZg==
   data.tar.gz: !binary |-
-    ZjhhOWM5NjgxMzE0NmM5ZTUyNWI0ODJiMDBkYTg3N2JmZDZhM2UyMg==
+    OTY4NTVlZTEzMGE3Zjc0NjZjYWIwZDg0ZGQ4MzM0NWVjNTFhZmZmYg==
 SHA512:
   metadata.gz: !binary |-
-    ZDIzMWMxY2ZkMTUxYzJhMzczZGE2MTVjYWY5MTNlNGY1N2JhOWVhNWU2MjVk
-    Y2U3ZmY4OTM1ZGM3YzVmMDdjYmQ3NTI0M2MwNTdmYmY1NjcyZDE5YzFjYWUw
-    NDBlYjBmYTFiYmU0OTQ3OTg3NzIzMzMxMmRkYmQ5NWMzNzdjNWY=
+    MmY5ZjgyOTY0ODg0YjgzNWRiZDk5MDQ2MmQ0YmI1NTk3ZTBiZmNlYzkzZGIz
+    ZWQ4ZjhiMGZhMmZjNGIwNzllYjE3ZGQwMDFkZGM1MTI4MGZjZDhkZTZlMjY0
+    ZTQxYmU0ZDI4NDlhMTUyNjRjNTQ0M2U2OGE4ZTUwNGM2ZmU1YzI=
   data.tar.gz: !binary |-
-    NzI1ZWFmZjI3NGM5YjY3NzM5N2NiMDgyZDUxZjY0YTU1M2U4ZDlmY2FhODky
-    NzZhYWY4NGMzYmNlOTkzZTU4OWI3ZDYzMmZlMWJkNjJkYWU0YjdhYWMxMzhi
-    MGQ1MTExMGY0MzQzMDA5Yzc3ZTJjYTVlMjhkNWZlYzFiYzRkYzE=
+    YjE0MzQ0MmIwZGVkM2Y3M2NmNDEzNTU2MzBkZjQyOWRlNzFmNWI3OWZlMjgx
+    YzI4YzRiNWU2OTFjYWRjNzc1OWU1NGNjODUyZTU1ODFjZTIxNGIyY2Q0YWQ0
+    YzE1MWNlZWU4NzFlOWYxYjUzZDE2MTY0ZTUzY2VmYzY4ODg5YjI=

data/.singularityrc

@@ -2,13 +2,22 @@
 
 batch :test do
   rubocop
-  bootcoveralls if flag? 'coveralls'
+  bootcoveralls { pr ENV.fetch('PULL', nil) } if flag? 'coveralls'
   rspec
 end
 
+batch :callback_integration do
+  rubocop
+  on_fail { fail 'fail callback' }
+  on_error { fail 'error callback' }
+  on_success { rspec }
+  always { puts 'Callback Integrations seem ok!' }
+end
+
 batch :ci do
   shelltask { command 'bundle install --path ./vendor' }
   shelltask { command 'bundle exec singularity_runner batch test --flags coveralls' }
+  shelltask { command 'bundle exec singularity_runner batch callback_integration' }
 end
 
 invoke_batch :test

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    singularity_dsl (2.2.2)
+    singularity_dsl (3.0.0)
       coveralls (~> 0.8.0)
       json (~> 1.0)
       mixlib-shellout (~> 2.0)
@@ -49,16 +49,16 @@ GEM
       rspec-core (~> 3.2.0)
       rspec-expectations (~> 3.2.0)
       rspec-mocks (~> 3.2.0)
-    rspec-core (3.2.2)
+    rspec-core (3.2.3)
       rspec-support (~> 3.2.0)
-    rspec-expectations (3.2.0)
+    rspec-expectations (3.2.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.2.0)
     rspec-mocks (3.2.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.2.0)
     rspec-support (3.2.2)
-    rubocop (0.29.1)
+    rubocop (0.30.0)
       astrolabe (~> 1.3)
       parser (>= 2.2.0.1, < 3.0)
       powerpack (~> 0.1)

data/lib/singularity_dsl/application.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 
+require 'singularity_dsl/dsl/dsl'
 require 'singularity_dsl/dsl/runner'
 require 'singularity_dsl/errors'
 require 'rainbow'
@@ -12,20 +13,21 @@ module SingularityDsl
     attr_reader :runner, :dsl
 
     def initialize
+      @dsl = Dsl::Dsl.new
       @runner = Dsl::Runner.new
     end
 
     def load_script(script)
-      @runner.load_ex_script script
+      dsl.load_ex_script script
     end
 
     def load_tasks(path)
-      @runner.dsl.load_tasks_in_path path
+      dsl.load_tasks_in_path path
     end
 
     def run(batch = false, pass_errors = false)
       begin
-        @runner.execute batch, pass_errors
+        @runner.execute dsl, batch, pass_errors
       # resource failed, :all_tasks not specified
       rescue ResourceFail => failure
         log_resource_fail failure
@@ -41,13 +43,13 @@ module SingularityDsl
     def post_task_runner_actions
       script_warn @runner.state.failures if @runner.state.failed
       script_error @runner.state.errors if @runner.state.error
-      @runner.post_actions
+      @runner.post_actions(dsl)
     end
 
     def change_list(list)
       list = [*list]
       list.sort!
-      @runner.dsl.changeset = list
+      dsl.changeset = list
     end
 
     private

data/lib/singularity_dsl/cli/command/app_runner_command.rb

@@ -46,8 +46,8 @@ module SingularityDsl
           flags.each do |pair|
             key = pair.split(':', 2).first
             val = pair.split(':', 2).last
-            app.runner.dsl.flag key if key == val
-            app.runner.dsl.flag key, val unless key == val
+            app.dsl.flag key if key == val
+            app.dsl.flag key, val unless key == val
           end
         end
       end

data/lib/singularity_dsl/dsl/dsl.rb

@@ -11,9 +11,8 @@ module SingularityDsl
   # DSL classes & fxs
   module Dsl
     # wrapper for DSL
-    class Dsl
+    class Dsl < EventStore
       include Changeset
-      include EventStore
       include Files
       include Utils
 
@@ -26,6 +25,16 @@ module SingularityDsl
         load_tasks_in_path default_task_dir
       end
 
+      def load_ex_proc(&block)
+        @registry = Registry.new
+        instance_eval(&block)
+      end
+
+      def load_ex_script(path)
+        @registry = Registry.new
+        instance_eval(::File.read path)
+      end
+
       def define_task(klass)
         raise_task_def_error klass if task_defined klass
         # because define_method is private

data/lib/singularity_dsl/dsl/event_store.rb

@@ -4,30 +4,30 @@ module SingularityDsl
   # DSL classes & fxs
   module Dsl
     # default methods to for DSL objects
-    module EventStore
-      attr_reader :error_proc, :fail_proc, :success_proc, :always_proc
+    class EventStore
+      attr_reader :error_procs, :fail_procs, :success_procs, :always_procs
 
       def initialize
-        @error_proc = proc {}
-        @fail_proc = proc {}
-        @success_proc = proc {}
-        @always_proc = proc {}
+        @error_procs = []
+        @fail_procs = []
+        @success_procs = []
+        @always_procs = []
       end
 
       def on_error(&block)
-        @error_proc = Proc.new(&block)
+        @error_procs << ::Proc.new(&block)
       end
 
       def on_fail(&block)
-        @fail_proc = Proc.new(&block)
+        @fail_procs << ::Proc.new(&block)
       end
 
       def on_success(&block)
-        @success_proc = Proc.new(&block)
+        @success_procs << ::Proc.new(&block)
       end
 
       def always(&block)
-        @always_proc = Proc.new(&block)
+        @always_procs << ::Proc.new(&block)
       end
     end
   end

data/lib/singularity_dsl/dsl/runner.rb

@@ -12,15 +12,15 @@ module SingularityDsl
     class Runner
       include SingularityDsl::Errors
 
-      attr_reader :state, :dsl
+      attr_reader :state
 
       def initialize
-        @dsl = Dsl.new
         @state = Runstate.new
       end
 
-      def execute(batch = false, pass_errors = false)
-        @dsl.registry.run_list(batch).each do |task|
+      def execute(dsl = nil, batch = false, pass_errors = false)
+        dsl ||= null_dsl
+        dsl.registry.run_list(batch).each do |task|
           task.execute.tap do |status|
             failed = task.failed_status status
             record_failure task if failed
@@ -29,18 +29,39 @@ module SingularityDsl
         end
       end
 
-      def load_ex_script(path)
-        @dsl.instance_eval(::File.read path)
+      def post_actions(dsl = nil)
+        dsl ||= null_dsl
+        trigger_events(dsl.error_procs, dsl) if error?
+        trigger_events(dsl.fail_procs, dsl) if failed?
+        trigger_events(dsl.success_procs, dsl) if success?
+        trigger_events(dsl.always_procs, dsl)
       end
 
-      def post_actions
-        @dsl.error_proc.call if @state.error
-        @dsl.fail_proc.call if @state.failed
-        @dsl.success_proc.call unless @state.failed || @state.error
-        @dsl.always_proc.call
+      private
+
+      def error?
+        @state.error
       end
 
-      private
+      def failed?
+        @state.failed
+      end
+
+      def success?
+        !(@state.failed || @state.error)
+      end
+
+      def null_dsl
+        @dsl ||= Dsl::Dsl.new
+      end
+
+      def trigger_events(procs, context_dsl = nil)
+        context_dsl ||= null_dsl
+        procs.each do |p|
+          context_dsl.load_ex_proc(&p)
+          execute context_dsl
+        end
+      end
 
       def record_failure(task)
         failure = klass_failed(task)

data/lib/singularity_dsl/version.rb

@@ -2,5 +2,5 @@
 
 # version const for gem
 module SingularityDsl
-  VERSION = '2.2.2'
+  VERSION = '3.0.0'
 end

data/spec/singularity_dsl/application_spec.rb

@@ -14,7 +14,7 @@ describe 'Application' do
   context '#load_script' do
     it 'just calls runner.load_ex_script' do
       stub_res = 'spooooooky ghooooost'
-      allow(app.runner).to(receive(:load_ex_script).and_return stub_res)
+      allow(app.dsl).to(receive(:load_ex_script).and_return stub_res)
       expect(app.load_script 'dummy').to eql stub_res
     end
   end

data/spec/singularity_dsl/dsl/dsl_spec.rb

@@ -29,6 +29,52 @@ describe 'Dsl' do
     end
   end
 
+  context '#load_ex_proc' do
+    let(:test_proc) { ::Proc.new { flag 'load_ex_proc_flag' } }
+    let(:registry_double) { double 'SingularityDsl::Dsl::Registry_DOUBLE' }
+
+    it 'instance_evals block' do
+      expect(dsl).to receive(:flag).with('load_ex_proc_flag')
+      dsl.load_ex_proc(&test_proc)
+    end
+
+    it 'wipes the existing task registry' do
+      expect(dsl.registry).to_not eql registry_double
+
+      allow(SingularityDsl::Dsl::Registry).to receive(:new)
+        .and_return(registry_double)
+
+      dsl.load_ex_proc(&test_proc)
+
+      expect(dsl.registry).to eql registry_double
+    end
+  end
+
+  context '#load_ex_script' do
+    let(:test_proc) { ::Proc.new {} }
+    let(:registry_double) { double 'SingularityDsl::Dsl::Registry_DOUBLE' }
+
+    it 'instance_evals contents of a file' do
+      allow(::File).to receive(:read).and_return('0')
+      expect(dsl).to receive(:instance_eval).with('0')
+      dsl.load_ex_script 'foo'
+    end
+
+    it 'wipes the existing task registry' do
+      expect(dsl.registry).to_not eql registry_double
+
+      allow(::File).to receive(:read).and_return('0')
+      allow(SingularityDsl::Dsl::Registry).to receive(:new)
+        .and_return(registry_double)
+
+      expect(dsl).to receive(:instance_eval).with('0')
+
+      dsl.load_ex_script 'foo'
+
+      expect(dsl.registry).to eql registry_double
+    end
+  end
+
   context '#load_tasks_in_path' do
     it 'does not load tasks that have already been required' do
       path = ::File.dirname(__FILE__) + '/../../lib/singularity_dsl/tasks'

data/spec/singularity_dsl/dsl/event_store_spec.rb

@@ -2,43 +2,38 @@
 
 require 'singularity_dsl/dsl/event_store'
 
-# container to include DslEventStore
-class EventStoreTest
-  include SingularityDsl::Dsl::EventStore
-end
-
 describe 'DslEventStore' do
-  let(:instance) { EventStoreTest.new }
+  let(:instance) { SingularityDsl::Dsl::EventStore.new }
 
   context '#on_error' do
-    it 'creates an error_proc' do
-      expect(instance.error_proc).to be_a_kind_of Proc
+    it 'creates an array of error_procs' do
+      expect(instance.error_procs).to be_a_kind_of Array
       instance.on_error {}
-      expect(instance.error_proc).to be_a_kind_of Proc
+      expect(instance.error_procs.first).to be_a_kind_of Proc
     end
   end
 
   context '#on_fail' do
-    it 'creates an fail_proc' do
-      expect(instance.fail_proc).to be_a_kind_of Proc
+    it 'creates an array of fail_procs' do
+      expect(instance.fail_procs).to be_a_kind_of Array
       instance.on_fail {}
-      expect(instance.fail_proc).to be_a_kind_of Proc
+      expect(instance.fail_procs.first).to be_a_kind_of Proc
     end
   end
 
   context '#on_success' do
-    it 'creates an error_proc' do
-      expect(instance.success_proc).to be_a_kind_of Proc
+    it 'creates an array of success_procs' do
+      expect(instance.success_procs).to be_a_kind_of Array
       instance.on_success {}
-      expect(instance.success_proc).to be_a_kind_of Proc
+      expect(instance.success_procs.first).to be_a_kind_of Proc
     end
   end
 
   context '#always' do
-    it 'creates an error_proc' do
-      expect(instance.always_proc).to be_a_kind_of Proc
+    it 'creates an array of procs to always execute' do
+      expect(instance.always_procs).to be_a_kind_of Array
       instance.always {}
-      expect(instance.always_proc).to be_a_kind_of Proc
+      expect(instance.always_procs.first).to be_a_kind_of Proc
     end
   end
 end

data/spec/singularity_dsl/dsl/runner_spec.rb

@@ -6,34 +6,84 @@ require 'singularity_dsl/runstate'
 require 'singularity_dsl/task'
 
 describe 'DslRunner' do
+  let!(:dsl) { SingularityDsl::Dsl::Dsl.new }
+  let!(:registry) { double('registry double') }
   let(:runner) { SingularityDsl::Dsl::Runner.new }
 
+  before :each do
+    allow(dsl).to receive(:registry).and_return(registry)
+  end
+
   context '#initialize' do
     it 'creates base state' do
       expect(runner.state).to be_kind_of SingularityDsl::Runstate
     end
-
-    it 'creates base DSL' do
-      expect(runner.dsl).to be_kind_of SingularityDsl::Dsl::Dsl
-    end
   end
 
   context '#execute' do
     it 'taps & evaluates failed task.execute statuses correctly' do
       task = SingularityDsl::Task.new
       allow(task).to receive(:execute).and_return(true)
-      allow(runner.dsl.registry).to receive(:run_list).and_return([task])
+      allow(dsl.registry).to receive(:run_list).and_return([task])
       expect(runner).to receive(:record_failure).with task
       expect(runner).to receive(:resource_fail).with task
-      runner.execute
+      runner.execute dsl
     end
   end
 
-  context '#load_ex_script' do
-    it 'instance_evals contents of a file' do
-      allow(::File).to receive(:read).and_return('0')
-      expect(runner.dsl).to receive(:instance_eval).with('0')
-      runner.load_ex_script 'foo'
+  context '#post_actions' do
+    let(:always_proc) { ::Proc.new { always_method } }
+    let(:error_proc) { ::Proc.new { error_method } }
+    let(:fail_proc) { ::Proc.new { fail_method } }
+    let(:success_proc) { ::Proc.new { success_method } }
+
+    before :each do
+      allow(SingularityDsl::Dsl::Dsl).to receive(:new).and_return(dsl)
+      allow(dsl).to receive(:always_procs).and_return([always_proc])
+
+      # to halt #execute
+      allow(dsl).to receive(:load_ex_proc).and_call_original
+      allow(registry).to receive(:run_list).and_return([])
+    end
+
+    it 'triggers error procs when there is an error' do
+      allow(runner.state).to receive(:error).and_return true
+      allow(dsl).to receive(:error_procs).and_return([error_proc])
+
+      expect(dsl).to receive(:always_method)
+      expect(dsl).to receive(:error_method)
+
+      # once for the error proc, other for always
+      expect(runner).to receive(:execute).with(dsl).twice
+
+      runner.post_actions dsl
+    end
+
+    it 'triggers fail procs when there is a failure' do
+      allow(runner.state).to receive(:failed).and_return true
+      allow(dsl).to receive(:fail_procs).and_return([fail_proc])
+
+      expect(dsl).to receive(:always_method)
+      expect(dsl).to receive(:fail_method)
+
+      # once for the fail proc, other for always
+      expect(runner).to receive(:execute).with(dsl).twice
+
+      runner.post_actions dsl
+    end
+
+    it 'triggers success procs when no failure nor error' do
+      allow(runner.state).to receive(:failed).and_return false
+      allow(runner.state).to receive(:error).and_return false
+      allow(dsl).to receive(:success_procs).and_return([success_proc])
+
+      expect(dsl).to receive(:always_method)
+      expect(dsl).to receive(:success_method)
+
+      # once for the success proc, other for always
+      expect(runner).to receive(:execute).with(dsl).twice
+
+      runner.post_actions dsl
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: singularity_dsl
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 3.0.0
 platform: ruby
 authors:
 - chr0n1x
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-06 00:00:00.000000000 Z
+date: 2015-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json