ventable 0.0.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.3
+script: "bundle exec rspec"
+notifications:
+  email:
+    recipients:
+      - kigster@gmail.com
+    on_success: never
+    on_failure: always

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ventable.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+#^syntax detection
+
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^ventable\.gemspec}) { "spec"}
+  watch(%r{^lib/(.+)\.rb$}) { "spec" }
+
+  watch(%r{^spec/.+_spec\.rb$})
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{spec/support/.*}) { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Konstantin Gredeskoul
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,116 @@
+[![Build status](https://secure.travis-ci.org/kigster/ventable.png)](http://travis-ci.org/kigster/ventable)
+
+# Ventable
+
+Simple eventing gem that implements Observable pattern, but with more options, ability to group observers and wrap
+them in arbitrary blocks of code.  For example, when a certain event fires, some observers may be called within
+a transaction context, while others maybe called outside of the transaction context.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ventable'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ventable
+
+## Usage
+
+1. Create your own plain ruby class that optionally carries some data important to the event. Include module Ventable::Event.
+2. Create one or more observers.  Observer can be any class that implements event handler method as a class method, such as a
+   generic method ```self.handle_event(event)``` or a more specific method mapped to the event name: say for event UserRegistered the
+   callback event would be ```self.handle_user_registered_event(event)```
+3. Register your observers with the event using ```notifies``` event method, or register groups using ```group``` method, and then
+   use ```notify``` with options ```inside: :group_name```
+4. Instantiate your event (optionally with data), and call fire!() method.
+
+## Example
+
+```ruby
+require 'ventable'
+
+# this is a custom Event class that has some data associated with it
+
+class AlarmSoundEvent
+  include Ventable::Event
+  attr_accessor :wakeup_time
+
+  def initialize(wakeup_time)
+    @wakeup_time = wakeup_time
+  end
+end
+
+# This class is an observer, interested in WakeUpEvents.
+class SleepingPerson
+  def self.handle_wake_up_event(event)
+    self.wake_up
+    puts "snoozing at #{event.wakeup_time}"
+    self.snooze(5)
+  end
+  #.. implementation
+end
+
+# Register the observer
+AlarmSoundEvent.notifies SleepingPerson
+
+# Create and fire the event
+AlarmSoundEvent.new(Date.new).fire!
+```
+
+## Using #configure and groups
+
+
+Events can be configured to call observers in groups, with an optional block around it.
+
+```ruby
+
+transaction = ->(b){
+  ActiveRecord::Base.transaction do
+    b.call
+  end
+}
+
+class SomeEvent
+  include Ventable::Event
+end
+
+SomeEvent.configure do
+  # first observer to be called
+  notifies FirstObserverClassToBeCalled
+
+  # this group will be notified next
+  group :transaction, &transaction
+
+  # this block is executed after the group
+  notifies inside: :transaction do
+    # perform block
+  end
+
+  # these observers are run inside the transaction block
+  notifies ObserverClass1, ObserverClass2, inside: :transaction
+
+  # this one is the last to be notified
+  notifies AnotherObserverClass
+end
+
+SomeEvent.new.fire!
+
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Author
+
+Konstantin Gredeskoul, @kig, http://github.com/kigster

data/Rakefile

@@ -0,0 +1,3 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+

data/lib/ventable.rb

@@ -0,0 +1,15 @@
+require "ventable/version"
+require "ventable/event"
+
+module Ventable
+end
+
+class String
+  def underscore
+    self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').
+        tr("-", "_").
+        downcase
+  end
+end

data/lib/ventable/event.rb

@@ -0,0 +1,86 @@
+require 'set'
+
+module ::Ventable
+  module Event
+    def self.included(klazz)
+      klazz.instance_eval do
+        @observers = Set.new
+        class << self
+          attr_accessor :observers
+        end
+      end
+
+      klazz.extend ClassMethods
+    end
+
+    def fire!
+      notify_observer_set(self.class.observers)
+    end
+
+    private
+
+    def notify_observer_set(observer_set)
+      observer_set.each do |observer_entry|
+        if observer_entry.is_a?(Hash)
+          around_block = observer_entry[:around_block]
+          inside_block = -> { notify_observer_set(observer_entry[:observers]) }
+          around_block.call(inside_block)
+        else
+          notify_observer(observer_entry)
+        end
+      end
+    end
+
+    def notify_observer(observer)
+      case observer
+        when Proc
+          observer.call(self)
+        else # class
+          notify_class_observer(observer)
+      end
+    end
+
+    def notify_class_observer(observer)
+      observer.respond_to?(self.class.default_callback_method) ?
+          observer.send(self.class.default_callback_method, self) :
+          observer.send(:handle_event, self)
+    end
+
+    module ClassMethods
+      def configure(&block)
+        class_eval(&block)
+      end
+
+      def notifies(*observer_list, &block)
+        options = {}
+        options.merge! observer_list.pop if observer_list.last.is_a?(Hash)
+        observer_set = self.observers
+        if options[:inside]
+          observer_entry = self.find_observer_group(options[:inside])
+          observer_set = observer_entry[:observers]
+        end
+        observer_list.each { |o| observer_set << o } unless observer_list.empty?
+        observer_set << block if block
+      end
+
+      def group(name, &block)
+        raise "Group #{name} already defined by #{g}" if  find_observer_group(name)
+        self.observers <<
+            { name: name,
+              around_block: block,
+              observers: Set.new
+            }
+      end
+
+      def find_observer_group(name)
+        self.observers.find { |o| o.is_a?(Hash) && o[:name] == name }
+      end
+
+      def default_callback_method
+        target = self
+        method = "handle_" + target.name.gsub(/.*::/,'').underscore.gsub(/_event/, '') + "_event"
+        method.to_sym
+      end
+    end
+  end
+end

data/lib/ventable/version.rb

@@ -0,0 +1,3 @@
+module Ventable
+  VERSION = "0.0.2"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+require 'rubygems'
+require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
+require 'ventable'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/ventable/ventable_spec.rb

@@ -0,0 +1,169 @@
+require 'ventable'
+require 'pp'
+describe Ventable do
+  before do
+    class TestEvent
+      include Ventable::Event
+    end
+  end
+
+  describe "including Ventable::Event" do
+    it "should create a class instance variable to keep observers" do
+      TestEvent.observers.should_not be_nil
+      TestEvent.observers.should be_a(Set)
+    end
+
+    it "should see observers variable from instance methods" do
+      observers = nil
+      TestEvent.new.instance_eval do
+        observers = self.class.observers
+      end
+      observers.should_not be_nil
+    end
+
+    it "should maintain separate sets of observers for each event" do
+      class AnotherEvent
+        include Ventable::Event
+      end
+      AnotherEvent.observers.object_id.should_not == TestEvent.observers.object_id
+    end
+  end
+
+  describe "#fire" do
+    before do
+      class TestEvent
+        include Ventable::Event
+      end
+    end
+
+    it "should properly call a Proc observer" do
+      run_block = false
+      event = nil
+      TestEvent.notifies do |e|
+        run_block = true
+        event = e
+      end
+      run_block.should_not be_true
+      event.should be_nil
+
+      # fire the event
+      TestEvent.new.fire!
+
+      run_block.should be_true
+      event.should_not be_nil
+    end
+
+    it "should properly call a class observer" do
+      TestEvent.instance_eval do
+        class << self
+          attr_accessor :flag
+        end
+      end
+
+      TestEvent.class_eval do
+        def set_flag!
+          self.class.flag = true
+        end
+      end
+      class TestEventObserver
+        def self.handle_test_event event
+          event.set_flag!
+        end
+      end
+      TestEvent.notifies TestEventObserver
+      TestEvent.flag.should be_false
+
+      TestEvent.new.fire!
+      TestEvent.flag.should be_true
+    end
+
+    it "should properly call a group of observers" do
+      transaction_called = false
+      transaction_completed = false
+      transaction = ->(observer_block) {
+        transaction_called = true
+        observer_block.call
+        transaction_completed = true
+      }
+
+      TestEvent.group :transaction, &transaction
+      observer_block_called = false
+
+      # this flag ensures that this block really runs inside
+      # the transaction group block
+      transaction_already_completed = false
+      event_inside = nil
+      TestEvent.notifies inside: :transaction do |event|
+        observer_block_called = true
+        transaction_already_completed = transaction_completed
+        event_inside = event
+      end
+
+      transaction_called.should be_false
+      transaction_already_completed.should be_false
+      observer_block_called.should be_false
+
+      TestEvent.new.fire!
+
+      transaction_called.should be_true
+      observer_block_called.should be_true
+      transaction_already_completed.should be_false
+      event_inside.should_not be_nil
+      event_inside.should be_a(TestEvent)
+    end
+  end
+
+  describe "#default_callback_method" do
+    before do
+      class SomeAwesomeEvent
+        include Ventable::Event
+      end
+
+      module Blah
+        class AnotherSweetEvent
+          include Ventable::Event
+        end
+      end
+
+      class SomeOtherStuffHappened
+        include Ventable::Event
+      end
+    end
+
+    it "should properly set the callback method name" do
+      SomeAwesomeEvent.default_callback_method.should == :handle_some_awesome_event
+      Blah::AnotherSweetEvent.default_callback_method.should == :handle_another_sweet_event
+      SomeOtherStuffHappened.default_callback_method.should == :handle_some_other_stuff_happened_event
+    end
+  end
+
+  describe "#configure" do
+    it "properly configures the event with observesrs" do
+      notified_observer = false
+      TestEvent.configure do
+        notifies do
+          notified_observer = true
+        end
+      end
+      TestEvent.new.fire!
+      notified_observer.should be_true
+    end
+
+    it "configures observers with groups" do
+      notified_observer = false
+      called_transaction = false
+      TestEvent.configure do
+        group :transaction, &->(b){
+          b.call
+          called_transaction = true
+        }
+        notifies inside: :transaction do
+          notified_observer = true
+        end
+      end
+      TestEvent.new.fire!
+      notified_observer.should be_true
+      called_transaction.should be_true
+    end
+  end
+end

data/ventable.gemspec

@@ -0,0 +1,22 @@
+
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/ventable/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Konstantin Gredeskoul"]
+  gem.email         = ["kigster@gmail.com"]
+  gem.description   = %q{Event/Observable design pattern in ruby}
+  gem.summary       = %q{Event/Observable design pattern in ruby}
+  gem.homepage      = "https://github.com/kigster/ventable"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "ventable"
+  gem.require_paths = ["lib"]
+  gem.version       = Ventable::VERSION
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rspec-mocks"
+  gem.add_development_dependency 'guard-rspec'
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: ventable
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Konstantin Gredeskoul
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Event/Observable design pattern in ruby
+email:
+- kigster@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/ventable.rb
+- lib/ventable/event.rb
+- lib/ventable/version.rb
+- spec/spec_helper.rb
+- spec/ventable/ventable_spec.rb
+- ventable.gemspec
+homepage: https://github.com/kigster/ventable
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Event/Observable design pattern in ruby
+test_files:
+- spec/spec_helper.rb
+- spec/ventable/ventable_spec.rb
+has_rdoc: