exel 1.4.0 → 1.5.1

data/spec/exel/events_spec.rb

@@ -1,97 +1,97 @@
 # frozen_string_literal: true
-module EXEL
-  describe Events do
-    class EventTest
-      include Events
 
-      def initialize(context)
-        @context = context
-      end
+describe EXEL::Events do
+  class EventTest
+    include EXEL::Events
+
+    def initialize(context)
+      @context = context
     end
+  end
 
-    subject(:events) { EventTest.new(context) }
-    let(:event_listener) { double(:event_listener) }
-    let(:context) { EXEL::Context.new(Events::LISTENERS_KEY => {event: [event_listener]}) }
+  subject(:events) { EventTest.new(context) }
 
-    it 'defines an attr_reader for context on the class it is included in' do
-      expect(events.context).to eq(context)
-    end
+  let(:event_listener) { double(:event_listener) }
+  let(:context) { EXEL::Context.new(EXEL::Events::LISTENERS_KEY => {event: [event_listener]}) }
 
-    describe '#register_listener' do
-      context 'when no listeners have been defined' do
-        let(:context) { EXEL::Context.new }
+  it 'defines an attr_reader for context on the class it is included in' do
+    expect(events.context).to eq(context)
+  end
 
-        it 'adds a new listener to the context' do
-          events.register_listener(context, :event, event_listener)
-          expect(context[Events::LISTENERS_KEY].fetch(:event)).to contain_exactly(event_listener)
-        end
-      end
+  describe '#register_listener' do
+    context 'when no listeners have been defined' do
+      let(:context) { EXEL::Context.new }
 
-      it 'registers multiple listeners for the same event' do
-        new_listener = double(:event_listener2)
-        events.register_listener(context, :event, new_listener)
-        expect(context[Events::LISTENERS_KEY].fetch(:event)).to contain_exactly(event_listener, new_listener)
+      it 'adds a new listener to the context' do
+        events.register_listener(context, :event, event_listener)
+        expect(context[EXEL::Events::LISTENERS_KEY].fetch(:event)).to contain_exactly(event_listener)
       end
     end
 
-    describe '#trigger' do
-      let(:context) { EXEL::Context.new }
-      let(:data) { {foo: 1} }
+    it 'registers multiple listeners for the same event' do
+      new_listener = double(:event_listener2)
+      events.register_listener(context, :event, new_listener)
+      expect(context[EXEL::Events::LISTENERS_KEY].fetch(:event)).to contain_exactly(event_listener, new_listener)
+    end
+  end
+
+  describe '#trigger' do
+    let(:context) { EXEL::Context.new }
+    let(:data) { {foo: 1} }
 
-      before { allow(events).to receive(:context).and_return(context) }
+    before { allow(events).to receive(:context).and_return(context) }
 
-      context 'when no events have been registered' do
-        it 'does not trigger anything' do
-          expect(event_listener).not_to receive(:event)
+    context 'when no events have been registered' do
+      it 'does not trigger anything' do
+        expect(event_listener).not_to receive(:event)
 
-          events.trigger(:event, data)
-        end
+        events.trigger(:event, data)
       end
+    end
 
-      context 'with a single listener registered for the event' do
-        before do
-          events.register_listener(context, :event, event_listener)
-        end
+    context 'with a single listener registered for the event' do
+      before do
+        events.register_listener(context, :event, event_listener)
+      end
 
-        it 'calls the listener with the context and event data' do
-          expect(event_listener).to receive(:event).with(context, data)
+      it 'calls the listener with the context and event data' do
+        expect(event_listener).to receive(:event).with(context, data)
 
-          events.trigger(:event, data)
-        end
+        events.trigger(:event, data)
+      end
 
-        it 'passes an empty hash if no data was given' do
-          expect(event_listener).to receive(:event).with(context, {})
+      it 'passes an empty hash if no data was given' do
+        expect(event_listener).to receive(:event).with(context, {})
 
-          events.trigger(:event)
-        end
+        events.trigger(:event)
       end
+    end
 
-      context 'with no listeners registered for the event' do
-        before do
-          events.register_listener(context, :other_event, event_listener)
-        end
+    context 'with no listeners registered for the event' do
+      before do
+        events.register_listener(context, :other_event, event_listener)
+      end
 
-        it 'does not trigger anything' do
-          expect(event_listener).not_to receive(:event)
+      it 'does not trigger anything' do
+        expect(event_listener).not_to receive(:event)
 
-          events.trigger(:event, data)
-        end
+        events.trigger(:event, data)
       end
+    end
 
-      context 'with multiple listeners registered for the event' do
-        let(:event_listener2) { double(:event_listener2) }
+    context 'with multiple listeners registered for the event' do
+      let(:event_listener2) { double(:event_listener2) }
 
-        before do
-          events.register_listener(context, :event, event_listener)
-          events.register_listener(context, :event, event_listener2)
-        end
+      before do
+        events.register_listener(context, :event, event_listener)
+        events.register_listener(context, :event, event_listener2)
+      end
 
-        it 'calls each listener with the context and event data' do
-          expect(event_listener).to receive(:event).with(context, data)
-          expect(event_listener2).to receive(:event).with(context, data)
+      it 'calls each listener with the context and event data' do
+        expect(event_listener).to receive(:event).with(context, data)
+        expect(event_listener2).to receive(:event).with(context, data)
 
-          events.trigger(:event, data)
-        end
+        events.trigger(:event, data)
       end
     end
   end

data/spec/exel/instruction_node_spec.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
-module EXEL
-  describe InstructionNode do
-    let(:context) { {} }
-    let(:instruction) { instance_double(Instruction, execute: nil) }
-    let(:child) { instance_double(ASTNode) }
-    subject(:node) { InstructionNode.new(instruction, [child]) }
 
-    it { is_expected.to be_kind_of(ASTNode) }
+describe EXEL::InstructionNode do
+  subject(:node) { EXEL::InstructionNode.new(instruction, children: [child]) }
 
-    describe '#run' do
-      it 'only executes the instruction' do
-        expect(instruction).to receive(:execute).with(context).once
-        node.run(context)
-      end
+  let(:context) { {} }
+  let(:instruction) { instance_double(EXEL::Instruction, execute: nil) }
+  let(:child) { instance_double(EXEL::ASTNode) }
 
-      it 'does not run it`s children' do
-        expect(child).not_to receive(:run)
-        node.run(context)
-      end
+  it { is_expected.to be_kind_of(EXEL::ASTNode) }
+
+  describe '#run' do
+    it 'only executes the instruction' do
+      expect(instruction).to receive(:execute).with(context).once
+      node.run(context)
+    end
+
+    it 'does not run it`s children' do
+      expect(child).not_to receive(:run)
+      node.run(context)
     end
   end
 end

data/spec/exel/instruction_spec.rb

@@ -1,63 +1,64 @@
 # frozen_string_literal: true
-module EXEL
-  describe Instruction do
-    subject(:instruction) { EXEL::Instruction.new(processor_class, args) }
-    let(:processor_class) { double(:processor_class, new: processor_instance) }
-    let(:processor_instance) { double(:processor_instance, process: nil) }
-    let(:args) { {arg1: 'arg_value1', arg2: {}} }
-    let(:context) { {context_key: 'context_value'} }
 
-    describe '#execute' do
-      it 'calls process on an instance of the processor class' do
-        expect(processor_class).to receive(:new).and_return(processor_instance)
-        expect(processor_instance).to receive(:process)
+describe EXEL::Instruction do
+  subject(:instruction) { EXEL::Instruction.new(processor_class, args) }
 
-        instruction.execute(context)
-      end
+  let(:processor_class) { double(:processor_class, new: processor_instance) }
+  let(:processor_instance) { double(:processor_instance, process: nil) }
+  let(:args) { {arg1: 'arg_value1', arg2: {}} }
+  let(:context) { {context_key: 'context_value'} }
 
-      it 'invokes the middleware chain' do
-        expect(EXEL.middleware).to receive(:invoke).with(processor_class, context, args)
-        instruction.execute(context)
-      end
+  describe '#execute' do
+    it 'calls process on an instance of the processor class' do
+      expect(processor_class).to receive(:new).and_return(processor_instance)
+      expect(processor_instance).to receive(:process)
 
-      it 'does not pass a copy of the context' do
-        allow(processor_class).to receive(:new) do |context_arg|
-          expect(context_arg).to be(context)
-          processor_instance
-        end
+      instruction.execute(context)
+    end
 
-        instruction.execute(context)
-      end
+    it 'invokes the middleware chain' do
+      expect(EXEL.middleware).to receive(:invoke).with(processor_class, context, args)
+      instruction.execute(context)
+    end
 
-      it 'adds args to the context' do
-        instruction.execute(context)
-        expect(context.keys).to include(*args.keys)
+    it 'does not pass a copy of the context' do
+      allow(processor_class).to receive(:new) do |context_arg|
+        expect(context_arg).to be(context)
+        processor_instance
       end
 
-      context 'with args' do
-        it 'passes the args to the processor' do
-          expect(processor_class).to receive(:new).with(hash_including(args))
-          instruction.execute(context)
-        end
+      instruction.execute(context)
+    end
+
+    it 'adds args to the context' do
+      instruction.execute(context)
+      expect(context.keys).to include(*args.keys)
+    end
+
+    context 'with args' do
+      it 'passes the args to the processor' do
+        expect(processor_class).to receive(:new).with(hash_including(args))
+        instruction.execute(context)
       end
+    end
 
-      context 'without args' do
-        let(:args) { nil }
+    context 'without args' do
+      let(:args) { nil }
 
-        it 'passes only the context to the processor' do
-          expect(processor_class).to receive(:new).with(context)
-          instruction.execute(context)
-        end
+      it 'passes only the context to the processor' do
+        expect(processor_class).to receive(:new).with(context)
+        instruction.execute(context)
       end
+    end
 
-      context 'with a subtree' do
-        let(:subtree) { double(:subtree) }
-        subject(:instruction) { EXEL::Instruction.new(processor_class, args, subtree) }
+    context 'with a subtree' do
+      subject(:instruction) { EXEL::Instruction.new(processor_class, args, subtree: subtree) }
 
-        it 'passes the subtree to the processor' do
-          expect(processor_instance).to receive(:process).with(subtree)
-          instruction.execute(context)
-        end
+      let(:subtree) { double(:subtree) }
+
+      it 'passes the subtree to the processor' do
+        expect(processor_instance).to receive(:process).with(subtree)
+        instruction.execute(context)
       end
     end
   end

data/spec/exel/job_spec.rb

@@ -1,116 +1,119 @@
 # frozen_string_literal: true
-module EXEL
-  describe Job do
-    describe '.define' do
-      let(:ast) { instance_double(SequenceNode, run: nil, start: nil) }
-      let(:block) { proc {} }
 
-      after { Job.registry.clear }
+describe EXEL::Job do
+  describe '.define' do
+    let(:ast) { instance_double(EXEL::SequenceNode, run: nil, start: nil) }
+    let(:block) { proc {} }
+
+    after { EXEL::Job.registry.clear }
+
+    it 'registers job definitions' do
+      EXEL::Job.define :test_job, &block
+      expect(EXEL::Job.registry[:test_job]).to eq(block)
+    end
+
+    it 'raises an exception if a job name is already in use' do
+      EXEL::Job.define :test_job, &block
+      expect { EXEL::Job.define :test_job, &block }.to raise_error 'Job :test_job is already defined'
+    end
+  end
+
+  describe '.run' do
+    let(:ast) { instance_double(EXEL::SequenceNode, run: nil, start: nil) }
+    let(:context) { instance_double(EXEL::Context) }
+
+    context 'with a string of DSL code' do
+      it 'parses the code' do
+        dsl_code = 'code'
+        expect(EXEL::Job::Parser).to receive(:parse).with(dsl_code).and_return(ast)
+        EXEL::Job.run(dsl_code, context)
+      end
 
-      it 'registers job definitions' do
-        Job.define :test_job, &block
-        expect(Job.registry[:test_job]).to eq(block)
+      it 'runs the AST returned by the parser' do
+        allow(EXEL::Job::Parser).to receive(:parse).and_return(ast)
+        expect(ast).to receive(:start).with(context)
+        EXEL::Job.run('code', context)
       end
 
-      it 'raises an exception if a job name is already in use' do
-        Job.define :test_job, &block
-        expect { Job.define :test_job, &block }.to raise_error 'Job :test_job is already defined'
+      it 'returns the context' do
+        allow(EXEL::Job::Parser).to receive(:parse).and_return(ast)
+        result = EXEL::Job.run('code', context)
+        expect(result).to be(context)
       end
     end
 
-    describe '.run' do
-      let(:ast) { instance_double(SequenceNode, run: nil, start: nil) }
-      let(:context) { instance_double(Context) }
+    context 'with a job name' do
+      context 'of a defined job' do
+        let(:block) { proc {} }
 
-      context 'with a string of DSL code' do
-        it 'parses the code' do
-          dsl_code = 'code'
-          expect(Job::Parser).to receive(:parse).with(dsl_code).and_return(ast)
-          Job.run(dsl_code, context)
+        before do
+          allow(EXEL::Job).to receive(:registry).and_return(test_job: block)
         end
 
-        it 'runs the AST returned by the parser' do
-          allow(Job::Parser).to receive(:parse).and_return(ast)
+        it 'runs the job' do
+          expect(EXEL::Job::Parser).to receive(:parse).with(block).and_return(ast)
           expect(ast).to receive(:start).with(context)
-          Job.run('code', context)
+          EXEL::Job.run(:test_job, context)
         end
 
         it 'returns the context' do
-          allow(Job::Parser).to receive(:parse).and_return(ast)
-          result = Job.run('code', context)
+          result = EXEL::Job.run(:test_job, context)
           expect(result).to be(context)
         end
       end
 
-      context 'with a job name' do
-        context 'of a defined job' do
-          let(:block) { proc {} }
-
-          before do
-            allow(Job).to receive(:registry).and_return(test_job: block)
-          end
-
-          it 'runs the job' do
-            expect(Job::Parser).to receive(:parse).with(block).and_return(ast)
-            expect(ast).to receive(:start).with(context)
-            Job.run(:test_job, context)
-          end
+      context 'of a undefined job' do
+        it 'returns nil' do
+          expect { EXEL::Job.run(:test_job, context) }.to raise_error('Job "test_job" not found')
+        end
+      end
+    end
+  end
 
-          it 'returns the context' do
-            result = Job.run(:test_job, context)
-            expect(result).to be(context)
+  describe 'mutation of arguments' do
+    module EXEL
+      module Processors
+        class TestProcessor
+          def initialize(context)
+            context[:array] << context[:arg]
           end
-        end
 
-        context 'of a undefined job' do
-          it 'returns nil' do
-            expect { Job.run(:test_job, context) }.to raise_error('Job "test_job" not found')
+          def process(_callback)
           end
         end
       end
     end
 
-    describe 'mutation of arguments' do
-      class TestProcessor
-        def initialize(context)
-          context[:array] << context[:arg]
-        end
-
-        def process(_callback)
-        end
+    it 'does not persist between runs' do
+      EXEL::Job.define :test do
+        process with: EXEL::Processors::TestProcessor, array: [], arg: context[:value]
       end
 
-      it 'does not persist between runs' do
-        Job.define :test do
-          process with: TestProcessor, array: [], arg: context[:value]
-        end
-
-        context = Context.new(value: 1)
-        Job.run(:test, context)
-        expect(context[:array]).to eq([1])
+      context = EXEL::Context.new(value: 1)
+      EXEL::Job.run(:test, context)
+      expect(context[:array]).to eq([1])
 
-        context = Context.new(value: 2)
-        Job.run(:test, context)
-        expect(context[:array]).to eq([2])
-      end
+      context = EXEL::Context.new(value: 2)
+      EXEL::Job.run(:test, context)
+      expect(context[:array]).to eq([2])
     end
   end
 
-  describe Job::Parser do
-    let(:parser) { Job::Parser.new }
-    let(:ast) { instance_double(SequenceNode, run: nil) }
+  describe EXEL::Job::Parser do
+    let(:parser) { EXEL::Job::Parser.new }
+    let(:ast) { instance_double(EXEL::SequenceNode, run: nil) }
 
     describe '#initialize' do
       it 'initializes a sequence node' do
-        expect(parser.ast).to be_kind_of(SequenceNode)
+        expect(parser.ast).to be_kind_of(EXEL::SequenceNode)
       end
     end
 
     describe '.parse' do
-      let(:parser) { instance_double(Job::Parser, ast: ast, instance_eval: nil) }
+      let(:parser) { instance_double(EXEL::Job::Parser, ast: ast, instance_eval: nil) }
 
       before do
-        allow(Job::Parser).to receive(:new).and_return(parser)
+        allow(EXEL::Job::Parser).to receive(:new).and_return(parser)
       end
 
       context 'given DSL code as a proc' do
@@ -120,7 +123,7 @@ module EXEL
             expect(block).to eq(dsl_proc)
           end
 
-          Job::Parser.parse(dsl_proc)
+          EXEL::Job::Parser.parse(dsl_proc)
         end
       end
 
@@ -129,12 +132,12 @@ module EXEL
           dsl_code = 'code'
           expect(parser).to receive(:instance_eval).with(dsl_code)
 
-          Job::Parser.parse(dsl_code)
+          EXEL::Job::Parser.parse(dsl_code)
         end
       end
 
       it 'returns the parsed AST' do
-        expect(Job::Parser.parse(proc {})).to eq(ast)
+        expect(EXEL::Job::Parser.parse(proc {})).to eq(ast)
       end
     end
 
@@ -142,18 +145,18 @@ module EXEL
       let(:block) { proc {} }
       let(:processor_class) { class_double(Class) }
 
-      before { allow(Job::Parser).to receive(:parse).and_return(ast) }
+      before { allow(EXEL::Job::Parser).to receive(:parse).and_return(ast) }
 
       context 'without a block' do
         it 'creates a process instruction' do
-          expect(Instruction).to receive(:new).with(processor_class, {arg1: 'arg1_value'}, nil)
+          expect(EXEL::Instruction).to receive(:new).with(processor_class, {arg1: 'arg1_value'}, subtree: nil)
 
           parser.process with: processor_class, arg1: 'arg1_value'
         end
 
         it 'appends an instruction node to the AST with no children' do
           expect(parser.ast).to receive(:add_child) do |node|
-            expect(node).to be_a_kind_of(InstructionNode)
+            expect(node).to be_a_kind_of(EXEL::InstructionNode)
             expect(node.children).to eq([])
           end
 
@@ -163,15 +166,15 @@ module EXEL
 
       context 'with a block' do
         it 'passes the parsed subtree to the instruction' do
-          expect(Job::Parser).to receive(:parse).with(block).and_return(ast)
-          expect(Instruction).to receive(:new).with(processor_class, {arg1: 'arg1_value'}, ast)
+          expect(EXEL::Job::Parser).to receive(:parse).with(block).and_return(ast)
+          expect(EXEL::Instruction).to receive(:new).with(processor_class, {arg1: 'arg1_value'}, subtree: ast)
 
           parser.process with: processor_class, arg1: 'arg1_value', &block
         end
 
         it 'appends an instruction node to the AST with the parsed block as its subtree' do
           expect(parser.ast).to receive(:add_child) do |node|
-            expect(node).to be_a_kind_of(InstructionNode)
+            expect(node).to be_a_kind_of(EXEL::InstructionNode)
             expect(node.children).to eq([ast])
           end
 
@@ -181,30 +184,30 @@ module EXEL
     end
 
     [
-      {method: :async, processor: Processors::AsyncProcessor},
-      {method: :split, processor: Processors::SplitProcessor},
-      {method: :run, processor: Processors::RunProcessor}
+        {method: :async, processor: EXEL::Processors::AsyncProcessor},
+        {method: :split, processor: EXEL::Processors::SplitProcessor},
+        {method: :run, processor: EXEL::Processors::RunProcessor},
     ].each do |data|
       describe "##{data[:method]}" do
         before do
-          allow(Job::Parser).to receive(:parse).and_return(ast)
+          allow(EXEL::Job::Parser).to receive(:parse).and_return(ast)
         end
 
         it "creates a #{data[:method]} instruction" do
-          expect(Instruction).to receive(:new).with(data[:processor], {arg1: 'arg1_value'}, ast)
+          expect(EXEL::Instruction).to receive(:new).with(data[:processor], {arg1: 'arg1_value'}, subtree: ast)
           parser.send(data[:method], arg1: 'arg1_value') {}
         end
 
         it 'parses the block given' do
           block = -> {}
-          expect(Job::Parser).to receive(:parse).with(block).and_return(ast)
+          expect(EXEL::Job::Parser).to receive(:parse).with(block).and_return(ast)
 
           parser.send(data[:method], &block)
         end
 
         it 'adds parsed subtree and instruction to the AST' do
           expect(parser.ast).to receive(:add_child) do |node|
-            expect(node).to be_a_kind_of(InstructionNode)
+            expect(node).to be_a_kind_of(EXEL::InstructionNode)
             expect(node.children).to eq([ast])
           end
 
@@ -215,7 +218,7 @@ module EXEL
 
     describe '#context' do
       it 'returns a DeferredContextValue' do
-        expect(parser.context).to be_a_kind_of(DeferredContextValue)
+        expect(parser.context).to be_a_kind_of(EXEL::DeferredContextValue)
       end
     end
 
@@ -223,15 +226,15 @@ module EXEL
       let(:listener_class) { class_double(Class) }
 
       it 'creates a listen instruction' do
-        expect(ListenInstruction).to receive(:new).with(:event, listener_class)
+        expect(EXEL::ListenInstruction).to receive(:new).with(:event, listener_class)
         parser.listen for: :event, with: listener_class
       end
 
       it 'adds an InstructionNode containing the listen instruction' do
         parser.listen for: :event, with: listener_class
         node = parser.ast.children.first
-        expect(node).to be_a_kind_of(InstructionNode)
-        expect(node.instruction).to be_a_kind_of(ListenInstruction)
+        expect(node).to be_a_kind_of(EXEL::InstructionNode)
+        expect(node.instruction).to be_a_kind_of(EXEL::ListenInstruction)
       end
     end
   end