signal 0.1.0

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Nando Vieira
+
+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,167 @@
+# Signal
+
+A simple observer implementation on POROs (Plain Old Ruby Object) and ActiveRecord objects.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem "signal"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install signal
+
+## Usage
+
+You can use Signal with PORO (Plain Old Ruby Object) and ActiveRecord.
+
+### Plain Ruby
+
+All you have to do is including the `Signal` module. Then you can add listeners and trigger events.
+
+```ruby
+class Status
+  include Signal
+
+  def ready!
+    emit(:ready)
+  end
+end
+
+status = Status.new
+status.before(:ready) { puts "Before the ready event!" }
+status.on(:ready) { puts "I'm ready!" }
+status.after(:ready) { puts "After the ready event!" }
+status.ready!
+#=> Before the ready event!
+#=> I'm ready!
+#=> After the ready event!
+```
+
+You can also pass objects that implement methods like `before_*`, `on_*` and `after_*`.
+
+```ruby
+class MyListener
+  def before_ready
+    puts "Before the ready event!"
+  end
+
+  def on_ready
+    puts "I'm ready!"
+  end
+
+  def after_ready
+    puts "After the ready event!"
+  end
+end
+
+status = Status.new
+status.listeners << MyListener.new
+status.ready!
+#=> Before the ready event!
+#=> I'm ready!
+#=> After the ready event!
+```
+
+Blocks are executed in the context of the observable object.
+
+```ruby
+class Contact
+  include Signal
+
+  attr_reader :name, :email
+
+  def initialize(name, email)
+    @name, @email = name, email
+  end
+
+  def output!
+    emit(:output)
+  end
+end
+
+contact = Contact.new("John Doe", "john@example.org")
+contact.on(:output) { puts name, email }
+contact.output!
+#=> John Doe
+#=> john@example.org
+```
+
+You can provide arguments while emitting a signal:
+
+```ruby
+class Arguments
+  include Signal
+end
+
+class MyListener
+  def on_args(a, b)
+    puts a, b
+  end
+end
+
+args = Arguments.new
+args.on(:args) {|a, b| puts a, b }
+args.listeners << MyListener.new
+args.emit(:args, 1, 2)
+```
+
+### ActiveRecord
+
+You can use Signal with ActiveRecord, which will give you some default events like `:create`, `:update`, `:remove` and `:validation`.
+
+```ruby
+class Thing < ActiveRecord::Base
+  include Signal::ActiveRecord
+
+  validates_presence_of :name
+end
+
+thing = Thing.new(:name => "Stuff")
+thing.on(:create) { puts updated_at, name }
+thing.on(:update) { puts updated_at, name }
+thing.on(:remove) { puts destroyed? }
+thing.on(:validation) { p errors.full_messages }
+
+thing.save!
+#=> 2013-01-26 10:32:39 -0200
+#=> Stuff
+
+thing.update_attributes(:name => "Updated stuff")
+#=> 2013-01-26 10:33:11 -0200
+#=> Updated stuff
+
+thing.update_attributes(:name => nil)
+#=> ["Name can't be blank"]
+
+thing.destroy
+#=> true
+```
+
+These are the available events:
+
+* `before(:create)`: triggered before creating the record (record is valid).
+* `on(:create)`: triggered after `before(:create)` event.
+* `after(:create)`: triggered after the `on(:create)` event.
+* `before(:update)`: triggered before updating the record (record is valid).
+* `on(:update)`: triggered when the `before(:update)` event.
+* `after(:update)`: triggered after the `on(:update)` event.
+* `before(:remove)`: triggered before removing the record.
+* `on(:remove)`: triggered after the `before(:remove)`.
+* `after(:remove)`: triggered after the `on(:remove)` event.
+* `before(:validation)`: triggered before validating record.
+* `on(:validation)`: triggered when record is invalid.
+* `after(:validation)`: triggered after validating record.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/activerecord_model.rb

@@ -0,0 +1,41 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "signal"
+require "active_record"
+
+ActiveRecord::Base.establish_connection({
+  :adapter => "sqlite3",
+  :database => ":memory:"
+})
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :things do |t|
+    t.string :name
+    t.timestamps
+  end
+end
+
+class Thing < ActiveRecord::Base
+  include Signal::ActiveRecord
+
+  validates_presence_of :name
+end
+
+thing = Thing.new(:name => "Stuff")
+thing.on(:create) { puts updated_at, name }
+thing.on(:update) { puts updated_at, name }
+thing.on(:remove) { puts destroyed? }
+thing.on(:validation) { p errors.full_messages }
+
+thing.save!
+#=> 2013-01-26 10:32:39 -0200
+#=> Stuff
+
+thing.update_attributes(:name => "Updated stuff")
+#=> 2013-01-26 10:33:11 -0200
+#=> Updated stuff
+
+thing.update_attributes(:name => nil)
+#=> ["Name can't be blank"]
+
+thing.destroy
+#=> true

data/examples/arguments.rb

@@ -0,0 +1,17 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "signal"
+
+class Arguments
+  include Signal
+end
+
+class MyListener
+  def on_args(a, b)
+    puts a, b
+  end
+end
+
+args = Arguments.new
+args.on(:args) {|a, b| puts a, b }
+args.listeners << MyListener.new
+args.emit(:args, 1, 2)

data/examples/block_context.rb

@@ -0,0 +1,20 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "signal"
+
+class Contact
+  include Signal
+
+  attr_reader :name, :email
+
+  def initialize(name, email)
+    @name, @email = name, email
+  end
+
+  def output!
+    emit(:output)
+  end
+end
+
+contact = Contact.new("John Doe", "john@example.org")
+contact.on(:output) { puts name, email }
+contact.output!

data/examples/blocks.rb

@@ -0,0 +1,16 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "signal"
+
+class Status
+  include Signal
+
+  def ready!
+    emit(:ready)
+  end
+end
+
+status = Status.new
+status.before(:ready) { puts "Before the ready event!" }
+status.on(:ready) { puts "I'm ready!" }
+status.after(:ready) { puts "After the ready event!" }
+status.ready!

data/examples/chain.rb

@@ -0,0 +1,56 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "signal"
+require "active_record"
+
+ActiveRecord::Base.establish_connection({
+  :adapter => "sqlite3",
+  :database => ":memory:"
+})
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :things do |t|
+    t.string :name
+    t.timestamps
+  end
+end
+
+class Thing < ActiveRecord::Base
+  include Signal::ActiveRecord
+
+  validates_presence_of :name
+end
+
+class MyListener
+  [:validation, :update, :create, :remove].each do |type|
+    class_eval <<-RUBY
+      def before_#{type}; puts __method__; end
+      def on_#{type}; puts __method__; end
+      def after_#{type}; puts __method__; end
+    RUBY
+  end
+end
+
+puts "\n=== Creating valid record"
+thing = Thing.new(:name => "Stuff")
+thing.listeners << MyListener.new
+thing.save
+
+puts "\n=== Creating invalid record"
+thing = Thing.new(:name => nil)
+thing.listeners << MyListener.new
+thing.save
+
+puts "\n=== Updating valid record"
+thing = Thing.create(:name => "Stuff")
+thing.listeners << MyListener.new
+thing.update_attributes(:name => "Updated stuff")
+
+puts "\n=== Updating invalid record"
+thing = Thing.create!(:name => "Stuff")
+thing.listeners << MyListener.new
+thing.update_attributes(:name => nil)
+
+puts "\n=== Removing record"
+thing = Thing.create(:name => "Stuff")
+thing.listeners << MyListener.new
+thing.destroy

data/examples/listener.rb

@@ -0,0 +1,28 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "signal"
+
+class Status
+  include Signal
+
+  def ready!
+    emit(:ready)
+  end
+end
+
+class MyListener
+  def before_ready
+    puts "Before the ready event!"
+  end
+
+  def on_ready
+    puts "I'm ready!"
+  end
+
+  def after_ready
+    puts "After the ready event!"
+  end
+end
+
+status = Status.new
+status.listeners << MyListener.new
+status.ready!

data/lib/signal/active_record.rb

@@ -0,0 +1,55 @@
+module Signal
+  module ActiveRecord
+    def self.included(base)
+      base.class_eval do
+        include Signal
+        include InstanceMethods
+
+        around_create     :around_create_signal
+        around_save       :around_save_signal
+        around_destroy    :around_destroy_signal
+        before_validation :before_validation_signal
+        after_validation  :after_validation_signal
+      end
+    end
+
+    module InstanceMethods
+      private
+      def around_create_signal
+        emit_signal(:before, :create)
+        yield
+        return unless persisted?
+        emit_signal(:on, :create)
+        emit_signal(:after, :create)
+      end
+
+      def around_save_signal
+        if new_record?
+          yield
+          return
+        end
+
+        emit_signal(:before, :update)
+        yield
+        emit_signal(:on, :update)
+        emit_signal(:after, :update)
+      end
+
+      def around_destroy_signal
+        emit_signal(:before, :remove)
+        yield
+        emit_signal(:on, :remove)
+        emit_signal(:after, :remove)
+      end
+
+      def before_validation_signal
+        emit_signal(:before, :validation)
+      end
+
+      def after_validation_signal
+        emit_signal(:on, :validation) if errors.any?
+        emit_signal(:after, :validation)
+      end
+    end
+  end
+end

data/lib/signal/listener.rb

@@ -0,0 +1,24 @@
+module Signal
+  class Listener
+    def initialize(context, type, event, &block)
+      @context = context
+      @type = type
+      @event = event
+      @block = block
+      @event_method = :"#{@type}_#{@event}"
+    end
+
+    def method_missing(method, *args)
+      return super unless method == @event_method
+      @context.instance_exec(*args, &@block)
+    end
+
+    def to_s
+      "<#{self.class} event: #{@event_method}>"
+    end
+
+    def respond_to_missing?(method_name, include_private)
+      method_name == @event_method
+    end
+  end
+end

data/lib/signal/version.rb

@@ -0,0 +1,3 @@
+module Signal
+  VERSION = "0.1.0"
+end

data/lib/signal.rb

@@ -0,0 +1,42 @@
+require "signal/active_record"
+require "signal/listener"
+require "signal/version"
+
+module Signal
+  def on(event, &block)
+    listeners << Listener.new(self, __method__, event, &block)
+    self
+  end
+
+  def before(event, &block)
+    listeners << Listener.new(self, __method__, event, &block)
+    self
+  end
+
+  def after(event, &block)
+    listeners << Listener.new(self, __method__, event, &block)
+    self
+  end
+
+  def emit(event, *args)
+    emit_signal(:before, event, *args)
+    emit_signal(:on, event, *args)
+    emit_signal(:after, event, *args)
+    nil
+  end
+
+  def listeners
+    @listeners ||= []
+  end
+
+  private
+  def emit_signal(type, event, *args)
+    listeners.each do |listener|
+      method_name = "#{type}_#{event}"
+
+      if listener.respond_to?(method_name)
+        listener.public_send(method_name, *args)
+      end
+    end
+  end
+end

data/signal.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require "./lib/signal/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "signal"
+  gem.version       = Signal::VERSION
+  gem.authors       = ["Nando Vieira"]
+  gem.email         = ["fnando.vieira@gmail.com"]
+  gem.description   = "A simple observer implementation for POROs (Plain Old Ruby Object) and ActiveRecord objects."
+  gem.summary       = gem.description
+  gem.homepage      = "http://github.com/fnando/signal"
+
+  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.require_paths = ["lib"]
+
+  gem.add_development_dependency "activerecord"
+  gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "rspec"
+end

data/spec/activerecord_spec.rb

@@ -0,0 +1,132 @@
+require "spec_helper"
+
+describe Signal::ActiveRecord do
+  let(:callable) { Callable.new }
+  let(:user) { User.new(:username => "johndoe") }
+
+  context "create event" do
+    it "triggers before event" do
+      user.before(:create, &callable)
+      callable.should_receive(:called).with(user)
+      user.save!
+    end
+
+    it "triggers event" do
+      user.on(:create, &callable)
+      callable.should_receive(:called).with(user)
+      user.save!
+    end
+
+    it "triggers after event" do
+      user.after(:create, &callable)
+      callable.should_receive(:called).with(user)
+      user.save!
+    end
+
+    it "doesn't trigger on/after events when record is invalid" do
+      user = User.new
+
+      on_callable = Callable.new
+      after_callable = Callable.new
+
+      user
+        .on(:create, &on_callable)
+        .after(:create, &after_callable)
+
+      on_callable.should_not_receive(:called)
+      after_callable.should_not_receive(:called)
+
+      user.save
+    end
+  end
+
+  context "validation event" do
+    it "triggers before event" do
+      user.before(:validation, &callable)
+      callable.should_receive(:called).with(user)
+      user.save!
+    end
+
+    it "triggers after event" do
+      user.after(:validation, &callable)
+      callable.should_receive(:called).with(user)
+      user.save!
+    end
+
+    it "triggers validation event when record is invalid" do
+      user.username = nil
+      user.on(:validation, &callable)
+      callable.should_receive(:called).with(user)
+      user.save
+    end
+
+    it "skips validation event when record is valid" do
+      user.on(:validation, &callable)
+      callable.should_not_receive(:called)
+      user.save!
+    end
+  end
+
+  context "update event" do
+    let(:user) { User.create!(:username => "johndoe") }
+
+    it "triggers before event" do
+      user.before(:update, &callable)
+      callable.should_receive(:called).with(user)
+      user.update_attributes!(:username => "johnd")
+    end
+
+    it "triggers on event" do
+      user.on(:update, &callable)
+      callable.should_receive(:called).with(user)
+      user.update_attributes!(:username => "johnd")
+    end
+
+    it "triggers after event" do
+      user.after(:update, &callable)
+      callable.should_receive(:called).with(user)
+      user.update_attributes!(:username => "johnd")
+    end
+
+    it "doesn't trigger on/after events when record is invalid" do
+      user.username = nil
+
+      on_callable = Callable.new
+      after_callable = Callable.new
+
+      user
+        .on(:update, &on_callable)
+        .after(:update, &after_callable)
+
+      on_callable.should_not_receive(:called)
+      after_callable.should_not_receive(:called)
+
+      user.save
+    end
+  end
+
+  context "remove event" do
+    let(:user) { User.create!(:username => "johndoe") }
+
+    it "triggers before event" do
+      user.before(:remove, &callable)
+      callable.should_receive(:called).with(user)
+
+      user.destroy
+    end
+
+    it "triggers on event" do
+      user.on(:remove, &callable)
+      callable.should_receive(:called).with(user)
+
+      user.destroy
+    end
+
+    it "triggers after event" do
+      user.after(:remove, &callable)
+      callable.should_receive(:called).with(user)
+
+      user.destroy
+    end
+  end
+end

data/spec/signal_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+describe Signal do
+  let(:observable) { Observable.new }
+  let(:callable) { Callable.new }
+
+  context "using blocks" do
+    it "triggers event" do
+      observable.on(:ready, &callable)
+      callable.should_receive(:called).with(observable)
+
+      observable.emit(:ready)
+    end
+
+    it "triggers event with arguments" do
+      observable.on(:ready, &callable)
+      callable.should_receive(:called).with(observable, 1, 2, 3)
+
+      observable.emit(:ready, 1, 2, 3)
+    end
+
+    it "triggers before event" do
+      observable.before(:ready, &callable)
+      callable.should_receive(:called).with(observable)
+
+      observable.emit(:ready)
+    end
+
+    it "triggers before event with arguments" do
+      observable.before(:ready, &callable)
+      callable.should_receive(:called).with(observable, 1, 2, 3)
+
+      observable.emit(:ready, 1, 2, 3)
+    end
+
+    it "triggers after event" do
+      observable.after(:ready, &callable)
+      callable.should_receive(:called).with(observable)
+
+      observable.emit(:ready)
+    end
+
+    it "triggers after event with arguments" do
+      observable.after(:ready, &callable)
+      callable.should_receive(:called).with(observable, 1, 2, 3)
+
+      observable.emit(:ready, 1, 2, 3)
+    end
+
+    it "chains events" do
+      before_callable = Callable.new
+      on_callable = Callable.new
+      after_callable = Callable.new
+
+      observable
+        .before(:ready, &before_callable)
+        .on(:ready, &on_callable)
+        .after(:ready, &after_callable)
+
+      before_callable.should_receive(:called).with(observable).ordered
+      on_callable.should_receive(:called).with(observable).ordered
+      after_callable.should_receive(:called).with(observable).ordered
+
+      observable.emit(:ready)
+    end
+  end
+
+  context "using listeners" do
+    it "triggers event for listener" do
+      callable.respond_to(:on_ready)
+      observable.listeners << callable
+      callable.should_receive(:called).with(callable)
+
+      observable.emit(:ready)
+    end
+
+    it "triggers event for listener with arguments" do
+      callable.respond_to(:on_ready)
+      observable.listeners << callable
+      callable.should_receive(:called).with(callable, 1, 2, 3)
+
+      observable.emit(:ready, 1, 2, 3)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require "bundler"
+Bundler.setup
+
+require "active_record"
+
+require "signal"
+require "support/observable"
+require "support/callable"
+require "support/user"
+
+ActiveRecord::Base.establish_connection({
+  :adapter => "sqlite3",
+  :database => ":memory:"
+})
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :users do |t|
+    t.string :username
+  end
+end

data/spec/support/callable.rb

@@ -0,0 +1,10 @@
+class Callable
+  def to_proc
+    callable = self
+    proc {|*args| callable.called(self, *args) }
+  end
+
+  def respond_to(method_name)
+    define_singleton_method(method_name, &to_proc)
+  end
+end

data/spec/support/observable.rb

@@ -0,0 +1,3 @@
+class Observable
+  include Signal
+end

data/spec/support/user.rb

@@ -0,0 +1,4 @@
+class User < ActiveRecord::Base
+  include Signal::ActiveRecord
+  validates_presence_of :username
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: signal
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Nando Vieira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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: sqlite3
+  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
+  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: A simple observer implementation for POROs (Plain Old Ruby Object) and
+  ActiveRecord objects.
+email:
+- fnando.vieira@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/activerecord_model.rb
+- examples/arguments.rb
+- examples/block_context.rb
+- examples/blocks.rb
+- examples/chain.rb
+- examples/listener.rb
+- lib/signal.rb
+- lib/signal/active_record.rb
+- lib/signal/listener.rb
+- lib/signal/version.rb
+- signal.gemspec
+- spec/activerecord_spec.rb
+- spec/signal_spec.rb
+- spec/spec_helper.rb
+- spec/support/callable.rb
+- spec/support/observable.rb
+- spec/support/user.rb
+homepage: http://github.com/fnando/signal
+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: A simple observer implementation for POROs (Plain Old Ruby Object) and ActiveRecord
+  objects.
+test_files:
+- spec/activerecord_spec.rb
+- spec/signal_spec.rb
+- spec/spec_helper.rb
+- spec/support/callable.rb
+- spec/support/observable.rb
+- spec/support/user.rb