informator 0.1.0 → 1.0.0

data/spec/unit/informator/publisher_spec.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+
+require "timecop"
+
+describe Informator::Publisher do
+
+  before { Timecop.freeze } # to allow time-dependent events being equal
+  after  { Timecop.return }
+
+  let(:pub_class)  { Informator::Foo = Class.new(described_class)      }
+  let(:publisher)  { pub_class.new attributes                          }
+  let(:attributes) { { foo: :FOO, bar: :BAR }                          }
+  let(:listener)   { double callback => nil, freeze: nil               }
+  let(:callback)   { :call                                             }
+  let(:name)       { :foo                                              }
+  let(:subscriber) { Informator::Subscriber.new listener, callback     }
+  let(:event)      { Informator::Event.new publisher, name, attributes }
+
+  describe ".new" do
+
+    subject { publisher }
+
+    it { is_expected.to be_frozen }
+
+    it "doesn't freeze attirbutes" do
+      expect { subject }.not_to change { attributes.frozen? }
+    end
+
+  end # describe .new
+
+  describe "#attributes" do
+
+    subject { publisher.attributes }
+
+    it { is_expected.to be_frozen      }
+    it { is_expected.to eql attributes }
+
+    context "by default" do
+
+      let(:publisher) { pub_class.new }
+
+      it { is_expected.to eql({}) }
+
+    end # context
+
+  end # describe #attributes
+
+  describe "#==" do
+
+    subject { publisher == other }
+
+    context "with the same types and attributes" do
+
+      let(:other) { publisher.subscribe(listener, callback) }
+      it { is_expected.to eql true }
+
+    end # context
+
+    context "with different types" do
+
+      let(:other) { described_class.new(attributes) }
+      it { is_expected.to eql false }
+
+    end # context
+
+    context "with different attributes" do
+
+      let(:other) { pub_class.new }
+      it { is_expected.to eql false }
+
+    end # context
+
+  end # describe #==
+
+  describe "#eql?" do
+
+    subject { publisher == other }
+    let(:other) { publisher.subscribe(listener, callback) }
+
+    it "aliases #==" do
+      expect(subject).to eql true
+    end
+
+  end # describe #==
+
+  describe "#inspect" do
+
+    subject { publisher.inspect }
+    it { is_expected.to eql "#<Informator::Foo @attributes=#{attributes}>" }
+
+  end # describe #inspect
+
+  describe "#to_s" do
+
+    subject { publisher.to_s }
+    it { is_expected.to eql publisher.inspect }
+
+  end # describe #to_s
+
+  describe "#subscribers" do
+
+    subject { publisher.subscribers }
+
+    it { is_expected.to eql Set.new }
+    it { is_expected.to be_frozen }
+
+  end # describe #attributes
+
+  describe "#subscribe" do
+
+    subject { publisher.subscribe(listener, callback) }
+
+    it { is_expected.to be_kind_of described_class }
+
+    it "preserves attributes" do
+      expect(subject.attributes).to eql attributes
+    end
+
+    it "registers new subscriber" do
+      other = Informator::Subscriber.new listener, "other"
+
+      updated = subject.subscribe(listener, "other")
+      expect(updated.subscribers).to contain_exactly subscriber, other
+    end
+
+    it "skips registered subscriber" do
+      updated = subject.subscribe(listener, callback)
+      expect(updated.subscribers).to contain_exactly subscriber
+    end
+
+  end # describe #subscribe
+
+  describe "#publish" do
+
+    subject { publisher.subscribe(listener, callback).publish name, attributes }
+
+    it "sends event to subscribers" do
+      expect(listener).to receive(callback).with(event)
+      subject
+    end
+
+    it { is_expected.to eql event }
+
+  end # describe #publish
+
+  describe "#publish!" do
+
+    let(:caller) { publisher.subscribe(listener, callback) }
+    subject { caller.publish! name, attributes }
+
+    it "sends event to subscribers" do
+      expect(listener).to receive(callback).with(event)
+      subject rescue nil
+    end
+
+    it "throws an exception" do
+      expect { subject }.to raise_error(ArgumentError)
+    end
+
+    it "carries the event" do
+      expect(catch(:published) { subject }).to eql event
+    end
+
+  end # describe #publish!
+
+  after { Informator.send :remove_const, :Foo }
+
+end # describe Informator::Publisher

data/spec/unit/informator/subscriber_spec.rb

@@ -2,84 +2,70 @@
 
 describe Informator::Subscriber do
 
-  let(:callback) { "foo" }
-  let(:event)    { double }
-  let(:object)   { double callback.to_sym => callback, freeze: nil }
-
-  subject(:subscriber) { described_class.new object, callback }
+  let(:callback)   { "foo"                                    }
+  let(:event)      { double                                   }
+  let(:listener)   { double callback => callback, freeze: nil }
+  let(:subscriber) { described_class.new listener, callback   }
 
   describe ".new" do
 
+    subject { subscriber }
     it { is_expected.to be_frozen }
 
   end # describe .new
 
-  describe "#object" do
+  describe "#listener" do
 
-    subject { subscriber.object }
-    it { is_expected.to eql object }
+    subject { subscriber.listener }
+    it { is_expected.to eql listener }
 
-  end # describe #object
+  end # describe #listener
 
   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
+    context "with the same listeners and callbacks" do
 
-      let(:other) { subscriber.dup }
+      let(:other) { described_class.new listener, callback }
       it { is_expected.to eql true }
 
     end # context
 
-    context "to event with another object" do
+    context "with different listeners" do
 
-      let(:other) { double freeze: nil }
+      let(:other) { described_class.new double(freeze: nil), callback }
       it { is_expected.to eql false }
 
     end # context
 
-    context "to event with other attributes" do
+    context "with different callbacks" do
 
-      let(:other) { described_class.new object, :other }
+      let(:other) { described_class.new listener, "other" }
       it { is_expected.to eql false }
 
     end # context
 
-    context "to non-subscriber" do
+  end # describe #==
 
-      let(:other) { :foo }
-      it { is_expected.to eql false }
+  describe "#notify" do
 
-    end # context
+    subject { subscriber.notify event }
 
-  end # describe #==
+    it "sends event to listener via callback" do
+      expect(listener).to receive(callback).with(event)
+      subject
+    end
+
+    it { is_expected.to eql event }
+
+  end # describe #notify
 
 end # describe Informator::Subscriber

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: informator
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Andrew Kozin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-12 00:00:00.000000000 Z
+date: 2015-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: equalizer
+  name: i18n
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.0'
+        version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.0'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: ice_nine
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: inflecto
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: equalizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
 - !ruby/object:Gem::Dependency
   name: hexx-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
 description: 
 email: andrew.kozin@gmail.com
 executables: []
@@ -87,14 +129,19 @@ files:
 - informator.gemspec
 - lib/informator.rb
 - lib/informator/event.rb
-- lib/informator/reporter.rb
+- lib/informator/publisher.rb
+- lib/informator/rspec.rb
 - lib/informator/subscriber.rb
 - lib/informator/version.rb
+- lib/rspec/shared.rb
+- spec/integration/en.yml
+- spec/integration/fr.yml
+- spec/integration/i18n.rb
+- spec/integration/rspec_spec.rb
 - spec/spec_helper.rb
 - spec/unit/informator/event_spec.rb
-- spec/unit/informator/reporter_spec.rb
+- spec/unit/informator/publisher_spec.rb
 - spec/unit/informator/subscriber_spec.rb
-- spec/unit/informator_spec.rb
 homepage: https://github.com/nepalez/informator
 licenses:
 - MIT
@@ -107,7 +154,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -121,8 +168,9 @@ specification_version: 4
 summary: Implementation of publish/subscribe design pattern
 test_files:
 - spec/spec_helper.rb
-- spec/unit/informator_spec.rb
+- spec/integration/i18n.rb
+- spec/integration/rspec_spec.rb
 - spec/unit/informator/event_spec.rb
-- spec/unit/informator/reporter_spec.rb
+- spec/unit/informator/publisher_spec.rb
 - spec/unit/informator/subscriber_spec.rb
 has_rdoc: 

data/lib/informator/reporter.rb

@@ -1,67 +0,0 @@
-# encoding: utf-8
-
-module Informator
-
-  # Builds, collects and publishes events to selected subscribers
-  #
-  # @example
-  #   reporter = Reporter.new
-  #   reporter.events # => []
-  #
-  #   reporter.remember :success
-  #   reporter.events # => [#<Event @type=:success @attributes={} @messages=[]>]
-  #
-  #   # this will call subscriber.notify for any event
-  #   reporter.notify subscriber
-  #   reporter.events # => []
-  #
-  # @api private
-  #
-  class Reporter
-
-    # @private
-    def initialize
-      @events = []
-      freeze # freezes the instance, but left events mutable!
-    end
-
-    # @!attribute [r] events
-    # @return [Array<Informator::Event>]
-    #   the list of registered events that havent'b been published yet
-    attr_reader :events
-
-    # @!method remember(type, messages, attributes)
-    # Registers the event to be published to subscribers
-    #
-    # @param (see Informator::Event.new)
-    #
-    # @return [self] itself
-    #
-    def remember(*args)
-      events << Event.new(*args)
-
-      self
-    end
-
-    # Notifies subscribers on events registered since the last notification
-    #
-    # Mutates [#events] by excluding all events having been published.
-    #
-    # @param [Informator::Subscriber, Array<Informator::Subscriber>] subscribers
-    #   the list of subscribers to be notified
-    #
-    # @return [Array<Informator::Event>] the list of published events
-    def notify(*subscribers)
-      events.dup.each { publish subscribers.flatten }
-    end
-
-    private
-
-    def publish(subscribers)
-      event = events.shift
-      subscribers.each { |subscriber| subscriber.notify(event) }
-    end
-
-  end # class Reporter
-
-end # module Informator