jace 0.0.2 → 0.1.1

data/spec/lib/jace/dispatcher_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Jace::Dispatcher do
+  subject(:dispatcher) do
+    described_class.new(
+      before: before,
+      after: after
+    )
+  end
+
+  let(:before) { nil }
+  let(:after)  { nil }
+  let(:person) { Person.new }
+
+  describe '#dispatch' do
+    context 'without before or after' do
+      let(:result) do
+        described_class.new.dispatch(person) { 10 }
+      end
+
+      it 'returns re result of block call' do
+        expect(result).to eq(10)
+      end
+
+      it 'executes in current context ignoring given context' do
+        expect(described_class.new.dispatch(person) { self })
+          .to eq(self)
+      end
+    end
+
+    context 'with before option' do
+      context 'with symbol' do
+        let(:before) { :init_age }
+
+        let(:result) do
+          dispatcher.dispatch(person) { person.age }
+        end
+
+        it 'returns result after running before code' do
+          expect(result).to eq(1)
+        end
+
+        it 'changes state of context object' do
+          expect { result }.to change(person, :age)
+            .from(nil).to(1)
+        end
+      end
+
+      context 'with block' do
+        let(:block)  { proc { @age = 10 } }
+        let(:before) { block }
+
+        let(:result) do
+          dispatcher.dispatch(person) { person.age }
+        end
+
+        it 'returns result after running before code' do
+          expect(result).to eq(10)
+        end
+
+        it 'changes state of context object' do
+          expect { result }.to change(person, :age)
+            .from(nil).to(10)
+        end
+      end
+
+      context 'with array' do
+        let(:block)  { proc { @brothers = @age ? 2 : 10 } }
+        let(:before) { [:init_age, block] }
+
+        let(:result) do
+          dispatcher.dispatch(person) do
+            person.age + person.brothers
+          end
+        end
+
+        it 'returns result after running all before code' do
+          expect(result).to eq(3)
+        end
+
+        it 'changes state of context object by block call' do
+          expect { result }.to change(person, :brothers)
+            .from(0).to(2)
+        end
+
+        it 'changes state of context object by method call' do
+          expect { result }.to change(person, :age)
+            .from(nil).to(1)
+        end
+      end
+    end
+
+    context 'with after option' do
+      context 'with symbol' do
+        let(:after) { :init_age }
+
+        let(:result) do
+          dispatcher.dispatch(person) { person.age }
+        end
+
+        it 'returns result before running after code' do
+          expect(result).to be_nil
+        end
+
+        it 'changes state of context object' do
+          expect { result }.to change(person, :age)
+            .from(nil).to(1)
+        end
+      end
+
+      context 'with block' do
+        let(:block) { proc { @age = 10 } }
+        let(:after) { block }
+
+        let(:result) do
+          dispatcher.dispatch(person) { person.age }
+        end
+
+        it 'returns result before running after code' do
+          expect(result).to be_nil
+        end
+
+        it 'changes state of context object' do
+          expect { result }.to change(person, :age)
+            .from(nil).to(10)
+        end
+      end
+
+      context 'with array' do
+        let(:block) { proc { @brothers = @age ? 2 : 10 } }
+        let(:after) { [:init_age, block] }
+
+        let(:result) do
+          dispatcher.dispatch(person) do
+            person.age.to_i + person.brothers
+          end
+        end
+
+        it 'returns result before running all after code' do
+          expect(result).to eq(0)
+        end
+
+        it 'changes state of context object by block call' do
+          expect { result }.to change(person, :brothers)
+            .from(0).to(2)
+        end
+
+        it 'changes state of context object by method call' do
+          expect { result }.to change(person, :age)
+            .from(nil).to(1)
+        end
+      end
+    end
+
+    context 'when no block is provided' do
+      let(:result) do
+        dispatcher.dispatch(person)
+      end
+
+      it do
+        expect(result).to be_nil
+      end
+
+      context 'when handlers are given' do
+        let(:before) { :init_age }
+        let(:after)  { :init_height }
+
+        it do
+          expect(result).to be_nil
+        end
+
+        it 'calls before handler' do
+          expect { result }
+            .to change(person, :age)
+            .to(1)
+        end
+
+        it 'calls after handler' do
+          expect { result }
+            .to change(person, :height)
+            .to(178)
+        end
+      end
+    end
+  end
+end

data/spec/lib/jace/executer_spec.rb

@@ -140,5 +140,39 @@ describe Jace::Executer do
         end
       end
     end
+
+    context 'when no block is provided' do
+      let(:result) do
+        described_class.call(context: person)
+      end
+
+      it do
+        expect(result).to be_nil
+      end
+
+      context 'when handlers are given' do
+        let(:result) do
+          described_class.call(
+            before: :init_age, after: :init_height, context: person
+          )
+        end
+
+        it do
+          expect(result).to be_nil
+        end
+
+        it 'calls before handler' do
+          expect { result }
+            .to change(person, :age)
+            .to(1)
+        end
+
+        it 'calls after handler' do
+          expect { result }
+            .to change(person, :height)
+            .to(178)
+        end
+      end
+    end
   end
 end

data/spec/lib/jace/handler_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Jace::Handler do
+  let(:context) { instance_double(Context) }
+
+  describe '#call' do
+    context 'when handler is initialized with a block' do
+      subject(:handler) { described_class.new { method_call } }
+
+      before { allow(context).to receive(:method_call) }
+
+      it 'calls the block' do
+        handler.call(context)
+
+        expect(context).to have_received(:method_call).once
+      end
+    end
+
+    context 'when handler is initialized with a proc' do
+      subject(:handler) { described_class.new(proc { method_call }) }
+
+      before { allow(context).to receive(:method_call) }
+
+      it 'calls the block' do
+        handler.call(context)
+
+        expect(context).to have_received(:method_call).once
+      end
+    end
+
+    context 'when handler is initialized with a symbol' do
+      subject(:handler) { described_class.new(:method_call) }
+
+      before { allow(context).to receive(:method_call) }
+
+      it 'calls the block' do
+        handler.call(context)
+
+        expect(context).to have_received(:method_call).once
+      end
+    end
+  end
+
+  describe '#to_proc' do
+    context 'when handler is initialized with a block' do
+      subject(:handler) { described_class.new { method_call } }
+
+      it do
+        expect(handler.to_proc).to be_a(Proc)
+      end
+
+      context 'when the proc is called' do
+        before { allow(context).to receive(:method_call) }
+
+        it 'calls the block' do
+          context.instance_eval(&handler.to_proc)
+
+          expect(context).to have_received(:method_call).once
+        end
+      end
+    end
+
+    context 'when handler is initialized with a proc' do
+      subject(:handler) { described_class.new(proc { method_call }) }
+
+      it do
+        expect(handler.to_proc).to be_a(Proc)
+      end
+
+      context 'when the proc is called' do
+        before { allow(context).to receive(:method_call) }
+
+        it 'calls the block' do
+          context.instance_eval(&handler.to_proc)
+
+          expect(context).to have_received(:method_call).once
+        end
+      end
+    end
+
+    context 'when handler is initialized with a symbol' do
+      subject(:handler) { described_class.new(:method_call) }
+
+      it do
+        expect(handler.to_proc).to be_a(Proc)
+      end
+
+      context 'when the proc is called' do
+        before { allow(context).to receive(:method_call) }
+
+        it 'calls the block' do
+          context.instance_eval(&handler.to_proc)
+
+          expect(context).to have_received(:method_call).once
+        end
+      end
+    end
+  end
+end

data/spec/lib/jace/registry_spec.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Jace::Registry do
+  subject(:registry) { described_class.new }
+
+  describe '#register' do
+    let(:event_name) { :event_name }
+    let(:expected_registry) do
+      { event_name: Jace::Dispatcher }
+    end
+
+    context 'when event is a symbol' do
+      it 'adds even to events registry' do
+        expect { registry.register(event_name) {} }
+          .to change(registry, :registry)
+          .to(expected_registry)
+      end
+
+      it 'adds event to event list' do
+        expect { registry.register(event_name) {} }
+          .to change(registry, :events)
+          .by([:event_name])
+      end
+    end
+
+    context 'when event is a string' do
+      let(:event_name) { 'event_name' }
+      let(:expected_registry) do
+        { event_name: Jace::Dispatcher }
+      end
+
+      it 'adds even to events registry' do
+        expect { registry.register(event_name) {} }
+          .to change(registry, :registry)
+          .to(expected_registry)
+      end
+
+      it 'adds event to event list' do
+        expect { registry.register(event_name) {} }
+          .to change(registry, :events)
+          .by([:event_name])
+      end
+    end
+
+    context 'when the event was already registerd' do
+      before { registry.register(event_name) {} }
+
+      it 'does not repace dispatcher' do
+        expect { registry.register(event_name) {} }
+          .not_to change(registry, :registry)
+      end
+
+      it 'adds event to event list' do
+        expect { registry.register(event_name) {} }
+          .not_to(change(registry, :events))
+      end
+    end
+
+    context 'when another event was already registerd' do
+      let(:expected_registry) do
+        {
+          event_name: Jace::Dispatcher,
+          other_event_name: Jace::Dispatcher
+        }
+      end
+
+      before { registry.register(:other_event_name) {} }
+
+      it 'adds even a callback to the event registry' do
+        expect { registry.register(event_name) {} }
+          .to change(registry, :registry)
+          .to(expected_registry)
+      end
+
+      it 'adds event to event list' do
+        expect { registry.register(event_name) {} }
+          .to change(registry, :events)
+          .by([:event_name])
+      end
+    end
+
+    context 'when registering for another instant' do
+      let(:expected_registry) do
+        {
+          event_name: Jace::Dispatcher
+        }
+      end
+
+      it 'adds even a callback to the event registry' do
+        expect { registry.register(event_name, :before) {} }
+          .to change(registry, :registry)
+          .to(expected_registry)
+      end
+
+      it 'adds event to event list' do
+        expect { registry.register(event_name) {} }
+          .to change(registry, :events)
+          .by([:event_name])
+      end
+    end
+
+    context 'when registering for another instant of an exiosting event' do
+      let(:expected_registry) do
+        {
+          event_name: { before: [Proc], after: [Proc] }
+        }
+      end
+
+      before { registry.register(event_name, :after) {} }
+
+      it 'does not repace dispatcher' do
+        expect { registry.register(event_name, :before) {} }
+          .not_to change(registry, :registry)
+      end
+
+      it 'does not add event to event list' do
+        expect { registry.register(event_name) {} }
+          .not_to(change(registry, :events))
+      end
+    end
+  end
+
+  describe '#trigger' do
+    let(:event_name) { :event_name }
+    let(:context)    { instance_double(Context) }
+
+    context 'when an event handler has been registered' do
+      before do
+        allow(context).to receive(:method_call)
+        allow(context).to receive(:other_method)
+        registry.register(event_name) { method_call }
+      end
+
+      it 'execute the event handler' do
+        registry.trigger(event_name, context) {}
+        expect(context).to have_received(:method_call)
+      end
+
+      it 'execute the block' do
+        registry.trigger(event_name, context) { context.other_method }
+        expect(context).to have_received(:other_method)
+      end
+    end
+
+    context 'when many event handlers have been registered' do
+      before do
+        allow(context).to receive(:method_call)
+        allow(context).to receive(:another_method_call)
+        allow(context).to receive(:other_method)
+
+        registry.register(event_name) { method_call }
+        registry.register(event_name) { another_method_call }
+      end
+
+      it 'execute the event handler' do
+        registry.trigger(event_name, context) {}
+        expect(context).to have_received(:method_call)
+      end
+
+      it 'execute the other event handler' do
+        registry.trigger(event_name, context) {}
+        expect(context).to have_received(:another_method_call)
+      end
+
+      it 'execute the block' do
+        registry.trigger(event_name, context) { context.other_method }
+        expect(context).to have_received(:other_method).once
+      end
+    end
+
+    context 'when another event handler has been registered' do
+      before do
+        allow(context).to receive(:method_call)
+        allow(context).to receive(:other_method)
+        registry.register(:other_event) { method_call }
+      end
+
+      it 'does not execute the event handler' do
+        registry.trigger(event_name, context) {}
+        expect(context).not_to have_received(:method_call)
+      end
+
+      it 'execute the block' do
+        registry.trigger(event_name, context) { context.other_method }
+        expect(context).to have_received(:other_method)
+      end
+    end
+
+    context 'when an event handler has not been registered' do
+      before do
+        allow(context).to receive(:other_method)
+      end
+
+      it 'execute the block' do
+        registry.trigger(event_name, context) { context.other_method }
+        expect(context).to have_received(:other_method)
+      end
+    end
+
+    context 'when no block is given' do
+      before do
+        allow(context).to receive(:method_call)
+
+        registry.register(event_name) { method_call }
+      end
+
+      it 'execute the event handler' do
+        registry.trigger(event_name, context)
+
+        expect(context).to have_received(:method_call)
+      end
+    end
+
+    describe 'order execution' do
+      let(:context) { SomeContext.new }
+      let(:expected_texts) do
+        [
+          'doing something before',
+          'doing something middle',
+          'doing something after'
+        ]
+      end
+
+      before do
+        registry.register(:the_event) { do_something(:after) }
+        registry.register(:the_event, :before) { do_something(:before) }
+      end
+
+      it 'runs the event handlers in order' do
+        registry.trigger(:the_event, context) do
+          context.do_something(:middle)
+        end
+
+        expect(context.text).to eq(expected_texts)
+      end
+    end
+  end
+end

data/spec/support/models/context.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Context
+  attr_reader :method_call, :other_method, :another_method_call
+end

data/spec/support/models/person.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Person
-  attr_accessor :age
+  attr_accessor :age, :height
 
   def brothers
     @brothers ||= 0
@@ -9,6 +9,10 @@ class Person
 
   private
 
+  def init_height
+    @height = 178
+  end
+
   def init_age
     @age ||= 1
   end

data/spec/support/models/some_context.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class SomeContext
+  def do_something(instant)
+    puts "doing something #{instant}"
+  end
+
+  def text
+    @text ||= []
+  end
+
+  def puts(string)
+    text << string
+  end
+end