informator 0.0.1

data/lib/informator/subscriber.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+module Informator
+
+  # Class Subscriber wraps the [#object] along with its [#callback] method
+  # to receive event notifications.
+  #
+  # @example The method [#notify] sends event to the [#object] via [#callback]
+  #   object     = Struct.new(:event).new
+  #   subscriber = Subscriber.new object, :event=
+  #   subscriber.frozen? # => true
+  #
+  #   event  = Informator::Event.new :success
+  #   # => #<Event @type=:success @data={} @messages=[]>
+  #
+  #   subscriber.notify event
+  #   object.event
+  #   # => #<Event @type=:success @data={} @messages=[]>
+  #
+  # @api private
+  #
+  class Subscriber
+
+    include Comparable
+
+    # @!attribute [r] object
+    #
+    # @return [Object] the object to send events to
+    #
+    attr_reader :object
+
+    # @!attribute [r] callback
+    #
+    # @return [Symbol] the name of the object methods to listen to events
+    #
+    attr_reader :callback
+
+    # @!scope class
+    # @!method new(object, callback)
+    # Builds the subscriber for given object and callback
+    #
+    # @param [Object] object
+    # @param [#to_sym] callback (:receive)
+    #
+    # @return [Informator::Subscriber]
+
+    # @private
+    def initialize(object, callback = :receive)
+      @object   = object
+      @callback = callback.to_sym
+      freeze
+    end
+
+    # Sends the event to the subscriber object via its callback
+    #
+    # @param [Informator::Event] event
+    #
+    # @return [Informator::Event] published event
+    #
+    def notify(event)
+      object.public_send callback, event
+
+      event
+    end
+
+    # Compares the subscriber to another one by their objects and callbacks
+    #
+    # @param [Object] other
+    #
+    # @return [Boolean]
+    #
+    def ==(other)
+      other.instance_of?(self.class) ? other.value.eql?(value) : false
+    end
+
+    protected
+
+    # Returns value to compare subscribers by
+    #
+    # @return [Array]
+    #
+    def value
+      [object, callback]
+    end
+
+  end # class Subscriber
+
+end # module Informator

data/lib/informator/version.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+module Informator
+
+  # The semantic version of the module.
+  # @see http://semver.org/ Semantic versioning 2.0
+  VERSION = "0.0.1".freeze
+
+end # module Informator

data/spec/integration/informator_spec.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+
+describe Informator do
+
+  subject(:informator) { klass.new }
+
+  let(:klass)    { Class.new { include Informator } }
+  let(:callback) { :on_received }
+  let(:listener) do
+    double receive: nil, callback => nil, foo: nil, bar: nil, receive: nil
+  end
+
+  before { informator.subscribe listener, callback }
+
+  describe "#subscribe" do
+
+    it "subscribes listeners one-by-one" do
+      informator.subscribe(listener, :foo).subscribe(listener, :bar)
+
+      expect(listener).to receive(callback).ordered
+      expect(listener).to receive(:foo).ordered
+      expect(listener).to receive(:bar).ordered
+      informator.publish :info
+    end
+
+    it "doesn't duplicate listener's callbacks" do
+      informator.subscribe(listener, callback)
+
+      expect(listener).to receive(callback).once
+      informator.publish :info
+    end
+
+    it "subscribes listener with :receive callback by default" do
+      informator.subscribe(listener)
+
+      expect(listener).to receive(:receive)
+      informator.publish :info
+    end
+
+  end # describe #subscribe
+
+  describe "#remember" do
+
+    it "keeps remembered events unpublished" do
+      expect(listener).not_to receive(callback)
+
+      informator.remember :info
+    end
+
+    it "remembers events until publishing" do
+      expect(listener).to receive(callback).once
+
+      informator.remember :info
+      informator.publish
+    end
+
+    it "returns itself to allow chaining" do
+      expect(informator.remember(:info).remember(:alert)).to eql informator
+    end
+
+  end # describe #remember
+
+  describe "#publish" do
+
+    it "publishes events" do
+      expect(listener).to receive(callback) do |event|
+        expect(event).to be_kind_of Informator::Event
+        expect(event.type).to eq :alert
+        expect(event.messages).to eql %w(foo)
+        expect(event.data).to eql(bar: :baz)
+      end
+
+      informator.publish :alert, "foo", bar: :baz
+    end
+
+    it "publishes all remembered events at once" do
+      expect(listener).to receive(callback).twice
+
+      informator.remember :info
+      informator.publish  :alert
+    end
+
+    it "can publish only remembered events without a new one" do
+      expect(listener).to receive(callback).once
+
+      informator.remember :info
+      informator.publish
+    end
+
+    it "returns events having been published" do
+      informator.remember :info
+      events = informator.publish :alert
+
+      expect(events).to be_kind_of Array
+      expect(events.map(&:class).uniq).to contain_exactly Informator::Event
+      expect(events.map(&:type)).to eql [:info, :alert]
+    end
+
+    it "forgets published events" do
+      informator.publish :info
+      expect(listener).not_to receive(callback)
+
+      informator.publish
+    end
+
+  end # describe #publish
+
+  describe "#publish!" do
+
+    it "publishes all remembered events at once" do
+      expect(listener).to receive(callback).twice
+
+      informator.remember :info
+      informator.publish!(:alert) rescue nil
+    end
+
+    it "can publish only remembered events without a new one" do
+      expect(listener).to receive(callback).once
+
+      informator.remember :info
+      informator.publish! rescue nil
+    end
+
+    it "forgets published events" do
+      informator.publish! :info rescue nil
+      expect(listener).not_to receive(callback)
+
+      informator.publish
+    end
+
+    it "throws :published" do
+      expect { informator.publish! }.to raise_error
+      expect { catch(:published) { informator.publish! } }.not_to raise_error
+    end
+
+    it "throws events having been published" do
+      informator.remember :info
+      events = catch(:published) { informator.publish! :alert }
+
+      expect(events).to be_kind_of Array
+      expect(events.map(&:class).uniq).to contain_exactly Informator::Event
+      expect(events.map(&:type)).to eql [:info, :alert]
+    end
+
+  end # describe #publish!
+
+end # describe Informator

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+begin
+  require "hexx-suit"
+  Hexx::Suit.load_metrics_for(self)
+rescue LoadError
+  require "hexx-rspec"
+  Hexx::RSpec.load_metrics_for(self)
+end
+
+# Loads the code under test
+require "informator"

data/spec/unit/informator/event_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+describe Informator::Event do
+
+  subject(:event) { described_class.new type, :foo, [:bar], baz: :qux }
+
+  let(:type) { "success" }
+
+  describe ".new" do
+
+    it { is_expected.to be_kind_of Comparable }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#type" do
+
+    subject { event.type }
+    it { is_expected.to eql type.to_sym }
+
+  end # describe #type
+
+  describe "#messages" do
+
+    subject { event.messages }
+    it { is_expected.to eql %w(foo bar) }
+
+  end # describe #messages
+
+  describe "#data" do
+
+    subject { event.data }
+    it { is_expected.to eq(baz: :qux) }
+
+  end # describe #data
+
+  describe "#==" do
+
+    subject { event == other }
+
+    context "to event with the same type and data" do
+
+      let(:other) { Class.new(described_class).new type, baz: :qux }
+      it { is_expected.to eql true }
+
+    end # context
+
+    context "to event with another type" do
+
+      let(:other) { described_class.new :error, baz: :qux }
+      it { is_expected.to eql false }
+
+    end # context
+
+    context "to event with other data" do
+
+      let(:other) { described_class.new :success, baz: "qux" }
+      it { is_expected.to eql false }
+
+    end # context
+
+    context "to non-event" do
+
+      let(:other) { :foo }
+      it { is_expected.to eql false }
+
+    end # context
+
+  end # describe #==
+
+end # describe Informator::Event

data/spec/unit/informator/reporter_spec.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+describe Informator::Reporter do
+
+  subject(:reporter) { described_class.new }
+
+  describe ".new" do
+
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#events" do
+
+    subject { reporter.events }
+    it { is_expected.to eql [] }
+
+  end # describe #events
+
+  describe "#remember" do
+
+    subject { reporter.remember(*options) }
+
+    let(:options) { [:foo, "bar", baz: :qux] }
+    let(:event)   { Informator::Event.new(*options) }
+
+    it "builds the event and adds it to #events" do
+      expect { subject }.to change { reporter.events }.by [event]
+    end
+
+    it { is_expected.to eql reporter }
+
+  end # describe #remember
+
+  describe "#notify" do
+
+    subject { reporter.notify(subscribers) }
+
+    let(:subscribers) { 2.times.map { double notify: nil } }
+    let!(:events) do
+      %i(foo bar).each(&reporter.method(:remember))
+      reporter.events.dup
+    end
+
+    it "notifies every subscriber on all #events" do
+      events.each do |event|
+        subscribers.each do |subscriber|
+          expect(subscriber).to receive(:notify).with(event).ordered
+        end
+      end
+
+      subject
+    end
+
+    it "clears #events" do
+      expect { subject }.to change { reporter.events }.to []
+    end
+
+    context "when error occured while publishing" do
+
+      before { allow(subscribers.first).to receive(:notify) { fail } }
+
+      it "removes tried #events" do
+        expect { subject rescue nil }
+          .to change { reporter.events }
+          .to [events.last]
+      end
+
+    end # context
+
+    it { is_expected.to eql events }
+
+  end # describe #notify
+
+end # describe Informator::Reporter

data/spec/unit/informator/subscriber_spec.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+describe Informator::Subscriber do
+
+  let(:callback) { "foo" }
+  let(:event)    { double }
+  let(:object)   { double callback.to_sym => callback }
+
+  subject(:subscriber) { described_class.new object, callback }
+
+  describe ".new" do
+
+    it { is_expected.to be_kind_of Comparable }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#object" do
+
+    subject { subscriber.object }
+    it { is_expected.to eql object }
+
+  end # describe #object
+
+  describe "#callback" do
+
+    subject { subscriber.callback }
+    it { is_expected.to eql callback.to_sym }
+
+    context "when callback isn't defined" do
+
+      let(:subscriber) { described_class.new object }
+      it { is_expected.to eql :receive }
+
+    end # context
+
+  end # describe #callback
+
+  describe "#notify" do
+
+    subject { subscriber.notify event }
+
+    it "sends event to object via callback" do
+      expect(object).to receive(callback).with(event)
+      subject
+    end
+
+    it { is_expected.to eql event }
+
+  end # describe #notify
+
+  describe "#==" do
+
+    subject { subscriber == other }
+
+    context "to subscriber with the same object and callback" do
+
+      let(:other) { subscriber.dup }
+      it { is_expected.to eql true }
+
+    end # context
+
+    context "to event with another object" do
+
+      let(:other) { described_class.new object.dup, callback }
+      it { is_expected.to eql false }
+
+    end # context
+
+    context "to event with other data" do
+
+      let(:other) { described_class.new object, :other }
+      it { is_expected.to eql false }
+
+    end # context
+
+    context "to non-subscriber" do
+
+      let(:other) { :foo }
+      it { is_expected.to eql false }
+
+    end # context
+
+  end # describe #==
+
+end # describe Informator::Subscriber