heed 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0345d1edb02b2cf539eec0ab3dd83d53b64ae55b
+  data.tar.gz: 6e49bd332ad4e1e77980a745ec3fa369fe2e263f
+SHA512:
+  metadata.gz: 4ed74d4af4b784f28e102e3f9828aec13772078d5e4a2555019c1476385a6ecb85e8a9651f4b1b9060dd662673e419ebf60c3ff9ea8460101a45340f1093e03b
+  data.tar.gz: b5f84d357dad9563f3eca222f0dbcca63096dffea597640e4779f0ea2a16b11e8539b38a1e2b07b40bd531e73eccff6360ec0b871744f3a822b50cfaa305d069

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

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/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0

data/Gemfile

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

data/History.md

@@ -0,0 +1,26 @@
+# History
+
+## 0.0.7
+
+* Change gem name to 'heed'
+
+## 0.0.6
+
+* remove Kernel#to_hark
+
+## 0.0.5
+
+* ruby 1.8.7 compat
+
+## 0.0.4
+
+* Adds Kernel#hearken
+* Adds coveralls & History
+
+## 0.0.3
+
+* Adds ruby < 1.9 support
+
+## 0.0.1 - 0.0.2
+
+* Initial release, slims API down to Kernel#hark

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ian White
+
+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,332 @@
+# Hark
+
+[![Gem Version](https://badge.fury.io/rb/ianwhite-hark.png)](https://rubygems.org/gems/ianwhite-hark)
+[![Build Status](https://travis-ci.org/ianwhite/hark.png)](https://travis-ci.org/ianwhite/hark)
+[![Dependency Status](https://gemnasium.com/ianwhite/hark.png)](https://gemnasium.com/ianwhite/hark)
+[![Code Climate](https://codeclimate.com/github/ianwhite/hark.png)](https://codeclimate.com/github/ianwhite/hark)
+[![Coverage Status](https://coveralls.io/repos/ianwhite/hark/badge.png)](https://coveralls.io/r/ianwhite/hark)
+
+Create a ad-hoc listeners with hark.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ianwhite-hark', :require => 'hark'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ianwhite-hark
+
+## What & Why?
+
+**hark** enables you to create a 'listener' object very easily.  It's for programming in the *hexagonal* or *tell, don't ask* style.
+The consumers of hark listeners don't know anything about hark.  Because hark makes it easy to create ad-hoc object, it's easy to get
+started with a tell-dont-ask style, in rails controllers for example.  For more detail see the 'Rationale' section.
+
+## Usage
+
+### Create a listener
+
+To create a listener object use `hark`.
+
+You can pass a symbol and block
+
+    hark :created do |user|
+      redirect_to(user, notice: "You have signed up!")
+    end
+
+The following methods are more suitable for a listener with multiple messages.
+
+A hash with callables as values
+
+    hark(
+      created: ->(user) { redirect_to(user, notice: "You have signed up!") },
+      invalid: ->(user) { @user = user; render "new" }
+    )
+
+    # assuming some methods for rendering and redirecting exist on the controller
+    hark(created: method(:redirect_to_user), invalid: method(:render_new))
+
+Or, a 'respond_to' style block
+
+    hark do |on|
+      on.created {|user| redirect_to(user, notice: "You have signed up!") }
+      on.invalid {|user| @user = user; render "new" }
+    end
+
+### Strict & lax listeners
+
+By default, hark listeners are 'strict', they will only respond to the methods defined on them.
+
+You create a 'lax' listener, responding to any message, by sending the `lax` message.
+
+    listener = hark(:foo) { "Foo" }
+
+    listener.bar
+    # => NoMethodError: undefined method `bar' for #<Hark::StrictListener:0x007fc91a03e568>
+
+    listener = listener.lax
+    listener.bar
+    # => []
+
+To make a strict listener send the `strict` message.
+
+### Combining listeners
+
+Here are some ways of combining listeners.
+
+    # redirect listener
+    listener = hark(created: method(:redirect_to_user))
+
+Add a message
+
+    listener = listener.hark :created do |user|
+      WelomeMailer.send_email(user)
+    end
+
+Combine with another listener
+
+    logger = listener.hark(created: ->(u) { logger.info "User #{u} created" } )
+    listener = listener.hark(logger)
+
+Combine with any object that support the same protocol
+
+    logger = UserLogger.new # responds to :created
+    listener = listener.hark(logger)
+
+Turn any object into a listener, adding new methods as we go
+
+    hark UserLogger.new do |on|
+      on.created {|user| Emailer.send_welcom_email(user) }
+    end
+
+Now, when listener is sent #created, all create handlers are called.
+
+### Sugar: `Kernel#hearken`
+
+Because of the precedence of the block operator, constructing ad-hoc listeners requires
+you to insert some parens, which might be seen as unsightly, e.g:
+
+    seller.request_valuation(item, (hark do |on|
+      on.valuation_requested {|valuation| redirect_to valuation}
+      on.invalid_item {|item| redirect_to item, error: "Item not evaluable" }
+    end))
+
+You may use Kernerl#hearken to create an ad-hoc listener using a passed block as follows
+
+    seller.hearken :request_valuation, item do |on|
+      on.valuation_requested {|valuation| redirect_to valuation}
+      on.invalid_item {|item| redirect_to item, error: "Item not evaluable" }
+    end
+
+If you want to combine listeners with an ad-hoc block, you may pass a 0-arity block that is
+yielded as the listener
+
+    seller.hearken :request_valuation, item do
+      hark valuation_notifier do |on|
+        on.valuation_requested {|valuation| redirect_to valuation}
+        on.invalid_item {|item| redirect_to item, error: "Item not evaluable" }
+      end
+    end
+
+### Return value
+
+Using the return value of a listener is not encouraged.  Hark is designed for a *tell, don't ask*
+style of coding.  That said the return value of a hark listener is an array of its handlers return values.
+
+    a = hark(:foo) { 'a' }
+    b = Object.new.tap {|o| o.singleton_class.send(:define_method, :foo) { 'b' } }
+    c = hark(foo: -> { 'c' }, bar: -> { 'c bar' })
+
+    a.foo           # => ["a"]
+    hark(a,b).foo   # => ["a", "b"]
+    hark(a,b,c).foo # => ["a", "b", "c"]
+
+### Immutable
+
+Hark listeners are immutable and `#lax`, `#strict`, and `#hark` all return new listeners.
+
+## Rationale
+
+When programming in the 'tell-dont-ask' or 'hexagonal' style, program flow is managed by passing listener, or
+response, objects to service objects, which call back depending on what happened.  This allows logic that is concerned with the caller's domain to remain isolated from the service object.
+
+The idea behind **hark** is that there should be little ceremony involved in the listener/response mechanics, and
+that simple listeners can easily be refactored into objects in their own right, without changing the protocols between
+the calling and servcie objects.
+
+To that end, service objects should not know anything other than the listener/response protocol, and shouldn't have to 'publish' their
+results beyond a simple method call.
+
+As a simple example, a user creation service object defines a response protocol as follows:
+
+* created_user(user) _the user was succesfully created_
+* invalid_user(user) _the user couldn't be created because it was invalid_
+
+The UserCreator object's main method will have some code as follows:
+
+    if # some logic that means the user params were valid and we could persist the user
+      response.created_user(user)
+    else
+      response.invalid_user(user)
+    end
+
+Let's say a controller is calling this, and you are using hark.  In the beginning you would do something like this:
+
+    def create
+      user_creator.call(user_params, hark do |on|
+        on.created_user {|user| redirect_to user, notice: "Welome!" }
+        on.invalid_user {|user| @user = user; render "new" }
+      end)
+    end
+
+This keeps the controller's handling of the user creation nicely separate from the saving of the user creator.
+
+Then, a requirement comes in to log the creation of users.  The first attempt might be this:
+
+    def create
+      user_creator.call(user_params, hark do |on|
+        on.created_user do |user|
+          redirect_to user, notice: "Welome!"
+          logger.info "User #{user} created"
+        end
+        on.invalid_user {|user| @user = user; render "new" }
+      end
+    end
+
+Then a requirement comes in to email users on succesful creation, there's an UserEmailer that responds
+to the same protocol.  Also, the UX team want to log invalid users.
+
+There's quite a lot going on now, we can tie it up as follows:
+
+    def create
+      response = hark(ui_response, UserEmailer.new, ux_team_response)
+      user_creator.call user_params, response
+    end
+
+    # UserEmailer responds to #created_user(user)
+
+    def ui_response
+      hark do |on|
+        on.created_user {|user| redirect_to user, notice: "Welome!" }
+        on.invalid_user {|user| @user = user; render "new" }
+      end
+    end
+
+    def ux_team_response
+      hark(:invalid_user) {|user| logger.info("User invalid: #{user}") }
+    end
+
+If some of the response code gets hairy, we can easily swap out hark ad-hoc objects for 'proper' ones.
+For example, the UI response might get a bit hairy, and so we make a new object.
+
+    def create
+      response = hark(UiResponse.new(self), UserEmailer.new, ux_team_response)
+      user_creator.call user_params, response
+    end
+
+    class UiResponse < SimpleDelegator
+      def created_user user
+        if request.format.json?
+          # ...
+        else
+          # ...
+        end
+      end
+
+      def invalid_user user
+        # ...
+      end
+    end
+
+Note that throughout this process we didn't have to modify the UserCreator code, even when we transitioned
+to/from hark for different repsonses/styles.
+
+### Testing your listeners
+
+Don't pay any attention to hark when you're testing, hark is just a utility to create listeners, and so what
+you should be testing is the protocol.
+
+For example the service object tests will test functionality that pertains to the actual creation of the user,
+and will test that the correct message is sent to the response in those circumstances.  Whereas the controller tests
+will mock out the service object, and test what happens when the service object sends the messages to the response as
+dictated by the protocol.
+
+    describe UserCreator do
+      let(:service) { described_class.new }
+
+      describe "#call params, response" do
+        subject { service.call params, response }
+
+        let(:response) { double }
+
+        context "when the user succesfully saves"
+          let(:params) { {name: "created user", # and other successful user params }
+
+          it "sends #created_user to the response with the created user" do
+            response.should_receive(:created_user) do |user|
+              user.name.should == "created user"
+            end
+            subject
+          end
+        end
+
+        context "when the user succesfully saves"
+          let(:params) { {name: "invalid user", # and invalid user params }
+
+          it "sends #invalid_user to the response with the created user" do
+            response.should_receive(:invalid_user) do |user|
+              # test that the object passed is the invalid user
+            end
+            subject
+          end
+        end
+      end
+    end
+
+    describe NewUserController do
+      before { controller.stub(user_creator: user_creator) } # or some other sensible way of injecting a fake user_creator
+
+      let(:user_creator) { double "User creator" }
+      let(:user) { double "A user" }
+
+      context "when the user_creator is succesful" do
+        before do
+          user_creator.stub :call do |params, response|
+            response.created_user(user)
+          end
+        end
+
+        it "should redirect to the user"
+
+        it "should email the user"
+
+        it "should log the creation of the user"
+      end
+
+      context "when the user_creator says the params are invalid" do
+        before do
+          user_creator.stub :call do |params, response|
+            response.invalid_user(user)
+          end
+        end
+
+        it "should render new with the user"
+
+        it "should log something for the UX team"
+      end
+    end
+
+
+## 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,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/hark.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hark/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "heed"
+  spec.version       = Hark::VERSION
+  spec.authors       = ["Ian White"]
+  spec.email         = ["ian.w.white@gmail.com"]
+  spec.description   = %q{Create ad-hoc listener objects with impunity}
+  spec.summary       = %q{Hark is a gem that enables  writing code in a "hexagonal architecture" or "tell don't ask" style}
+  spec.homepage      = "http://github.com/ianwhite/hark"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+  if RUBY_VERSION > "1.9"
+    spec.add_development_dependency "coveralls"
+  end
+end

data/lib/hark.rb

@@ -0,0 +1,11 @@
+require "hark/version"
+require "hark/ad_hoc"
+require "hark/dispatcher"
+require "hark/listener"
+require "hark/core_ext"
+
+module Hark
+  def self.from(*args, &block)
+    Listener.new(*args, &block)
+  end
+end

data/lib/hark/ad_hoc.rb

@@ -0,0 +1,48 @@
+module Hark
+  # AdHoc is a tiny class to facilitate creating an ad-hoc object that from either a hash or proc.
+  #
+  # Eg. from a hash:
+  #
+  #   handler = AdHoc.new(success: (o)-> { o.great_success }, failure: (o)-> { o.failed } )
+  #
+  # Eg. from a 'response' style block:
+  #
+  #   handler = AdHoc.new do |on|
+  #     on.success {|o| o.great_success }
+  #     on.failure {|o| o.failed }
+  #   end
+  #
+  # Eg. adding methods after creation
+  #
+  #   obj = AdHoc.new
+  #   obj.add_method!(:foo) { "bar" }
+  #
+  # All blocks keep their original binding.  This makes AdHoc suitable for creating
+  # ad-hoc responses from controller type objects.
+  #
+  class AdHoc
+    def self.new hash = {}, &proc
+      super().tap do |ad_hoc|
+        AddMethodsFromProc.new(proc, ad_hoc) if block_given?
+        hash.each {|method, body| ad_hoc.add_method!(method, &body) }
+      end
+    end
+
+    def add_method!(method, &body)
+      singleton_class = class << self; self; end
+      singleton_class.send(:define_method, method) {|*args, &block| body.call(*args, &block) }
+    end
+
+    class AddMethodsFromProc
+      def initialize proc, ad_hoc
+        @ad_hoc = ad_hoc
+        proc.call(self)
+      end
+
+      def method_missing method, *, &body
+        @ad_hoc.add_method!(method, &body)
+      end
+    end
+  end
+end
+

data/lib/hark/core_ext.rb

@@ -0,0 +1,10 @@
+module Kernel
+  def hark *args, &block
+    Hark.from *args, &block
+  end
+
+  def hearken method, *args, &block
+    listener = (block.arity == 1) ? hark(&block) : block.call
+    send method, *args + [listener]
+  end
+end

data/lib/hark/dispatcher.rb

@@ -0,0 +1,50 @@
+module Hark
+  class Dispatcher
+    #  from(:success) do
+    #    "success"
+    #  end
+    #
+    #  from(success: ->{ "success" })
+    #
+    #  from do |on|
+    #    on.success { "success" }
+    #  end
+    #
+    def self.from(*args, &block)
+      if block
+        args << (args.last.is_a?(Symbol) ? {args.pop => block} : block)
+      end
+
+      new args.map{|o| to_handler(o) }.flatten.freeze
+    end
+
+    def self.to_handler object
+      case object
+      when Listener then object.dispatcher.handlers
+      when Dispatcher then object.handlers
+      when Hash then AdHoc.new(object)
+      when Proc then AdHoc.new(&object)
+      else object
+      end
+    end
+
+    attr_reader :handlers
+
+    def initialize handlers
+      @handlers = handlers
+      freeze
+    end
+
+    def handles? method
+      handlers.any? {|handler| handler.respond_to?(method) }
+    end
+
+    def handle method, *args, &block
+      results = []
+      handlers.each do |handler|
+        results << handler.send(method, *args, &block) if handler.respond_to?(method)
+      end
+      results
+    end
+  end
+end

data/lib/hark/listener.rb

@@ -0,0 +1,58 @@
+module Hark
+  # A Listener holds a dispatcher, which it dispatches messages to
+  #
+  # A listener is by default a 'strict' listener, it will raise NoMethodError if
+  # it is sent a message it doesn't know how to handle.
+  #
+  # A listener can be turned into a 'lax' listener, by sending it the #lax message.
+  # A lax listener will silently swallow any unknown messages.
+  class Listener
+    def self.new *args, &block
+      self == Listener ? StrictListener.new(*args, &block) : super(*args, &block)
+    end
+
+    attr_reader :dispatcher
+
+    def initialize(*args, &block)
+      @dispatcher = Dispatcher.from(*args, &block)
+      freeze
+    end
+
+    def strict
+      StrictListener.new dispatcher
+    end
+
+    def lax
+      LaxListener.new dispatcher
+    end
+
+    def hark *args, &block
+      self.class.new dispatcher, *args, &block
+    end
+  end
+
+  class StrictListener < Listener
+    def respond_to?(method, *args)
+      super || dispatcher.handles?(method)
+    end
+
+    def method_missing *args, &block
+      results = dispatcher.handle(*args, &block)
+      if results.length > 0
+        results
+      else
+        super
+      end
+    end
+  end
+
+  class LaxListener < Listener
+    def respond_to? *args
+      true
+    end
+
+    def method_missing *args, &block
+      dispatcher.handle(*args, &block)
+    end
+  end
+end

data/lib/hark/version.rb

@@ -0,0 +1,3 @@
+module Hark
+  VERSION = "0.0.7"
+end

data/spec/hark_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+require 'hark'
+
+describe Hark do
+  let(:transcript) { [] }
+
+  class PlainListener < Struct.new(:transcript)
+    def success(value)
+      transcript.push [:succeeded, value]
+    end
+
+    def failure(value)
+      transcript.push [:failed, value]
+    end
+  end
+
+  shared_examples_for "a success/failure listener" do
+    describe "success" do
+      before { listener.success(42) }
+      it { transcript.should == [[:succeeded, 42]] }
+    end
+
+    describe "failure" do
+      before { listener.failure(54) }
+      it { transcript.should == [[:failed, 54]] }
+    end
+  end
+
+  shared_examples_for "a strict listener" do
+    it { strict_listener.should_not respond_to(:unknown) }
+    it { expect{ strict_listener.unknown }.to raise_error(NoMethodError) }
+  end
+
+  shared_examples_for "a lax listener" do
+    it { lax_listener.should respond_to(:unknown) }
+    it { lax_listener.unknown.should == [] }
+  end
+
+  shared_examples_for "a success/failure hark listener" do
+    it_should_behave_like "a success/failure listener"
+    it_should_behave_like "a strict listener" do
+      let(:strict_listener) { listener }
+    end
+
+    context "when made lax" do
+      let(:lax_listener) { listener.lax }
+      it_should_behave_like "a lax listener"
+
+      context "and made strict again" do
+        let(:strict_listener) { lax_listener.strict }
+        it_should_behave_like "a strict listener"
+      end
+    end
+  end
+
+  describe "A plain (non hark) listener object" do
+    let(:listener) { PlainListener.new(transcript) }
+
+    it_should_behave_like "a success/failure listener"
+    it_should_behave_like "a strict listener" do
+      let(:strict_listener) { listener }
+    end
+  end
+
+  describe "hark with respond_to style block" do
+    let(:listener) do
+      hark do |on|
+        on.success {|v| transcript.push [:succeeded, v] }
+        on.failure {|v| transcript.push [:failed, v] }
+      end
+    end
+
+    it_should_behave_like "a success/failure hark listener"
+  end
+
+  describe "hark with callables" do
+    let(:listener) do
+      hark :success => lambda{|v| transcript.push [:succeeded, v] }, :failure => lambda{|v| transcript.push [:failed, v] }
+    end
+
+    it_should_behave_like "a success/failure hark listener"
+  end
+
+  describe "hark built up in steps" do
+    let(:listener) do
+      l = hark
+      l = l.hark(:success) {|v| transcript.push [:succeeded, v] }
+      l = l.hark(:failure) {|v| transcript.push [:failed, v] }
+    end
+
+    it_should_behave_like "a success/failure hark listener"
+  end
+
+  describe "#hark(object)" do
+    let(:listener) { hark PlainListener.new(transcript) }
+
+    it_should_behave_like "a success/failure hark listener"
+  end
+
+  describe "combine two listeners together" do
+    let(:logger) { hark(:signup_user) {|user| transcript << "User #{user} signed up" } }
+    let(:emailer) { hark(:signup_user) {|user| transcript << "Emailed #{user}" } }
+
+    shared_examples_for "combined listeners" do
+      before { listener.signup_user("Fred") }
+
+      it { transcript.should == ["User Fred signed up", "Emailed Fred"] }
+    end
+
+    it_behaves_like "combined listeners" do
+      let(:listener) { logger.hark(emailer) }
+    end
+
+    it_behaves_like "combined listeners" do
+      let(:listener) { hark(logger, emailer) }
+    end
+
+    it_behaves_like "combined listeners" do
+      let(:listener) do
+        hark logger do |on|
+          on.signup_user {|user| transcript << "Emailed #{user}" }
+        end
+      end
+    end
+  end
+
+  describe "lax/strict is preserved on #hark" do
+    it { hark.lax.hark.should be_a Hark::LaxListener }
+    it { hark.strict.hark.should be_a Hark::StrictListener }
+  end
+
+  describe "when methods return falsy" do
+    let(:listener) { hark(:foo) { false } }
+
+    it { expect{ listener.foo }.to_not raise_error }
+    it { listener.foo.should == [false] }
+  end
+
+  describe "#hearken :method" do
+    let(:object) do
+      Object.new.tap do |obj|
+        class << obj
+          def foo arg1, arg2, listener
+            listener.foo(arg1)
+            listener.bar(arg2)
+          end
+        end
+      end
+    end
+
+    context "with 1 arity block" do
+      it "sends :method with an ad-hoc listener created from the block" do
+        object.hearken :foo, "ONE", "TWO" do |on|
+          on.foo {|a| transcript << [:foo, a] }
+          on.bar {|a| transcript << [:bar, a] }
+        end
+        transcript.should == [[:foo, "ONE"], [:bar, "TWO"]]
+      end
+    end
+
+    context "with 0 arity block" do
+      it "sends :method with listener created by yielding to the block" do
+        foo = hark(:foo) {|a| transcript << [:foo, a] }
+
+        object.hearken :foo, "ONE", "TWO" do
+          hark(foo, :bar) {|a| transcript << [:bar, a] }
+        end
+        transcript.should == [[:foo, "ONE"], [:bar, "TWO"]]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.dirname('../lib')
+
+require 'rspec'
+
+begin
+  require 'coveralls'
+  Coveralls.wear!
+rescue LoadError
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: heed
+version: !ruby/object:Gem::Version
+  version: 0.0.7
+platform: ruby
+authors:
+- Ian White
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Create ad-hoc listener objects with impunity
+email:
+- ian.w.white@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .coveralls.yml
+- .gitignore
+- .travis.yml
+- Gemfile
+- History.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- hark.gemspec
+- lib/hark.rb
+- lib/hark/ad_hoc.rb
+- lib/hark/core_ext.rb
+- lib/hark/dispatcher.rb
+- lib/hark/listener.rb
+- lib/hark/version.rb
+- spec/hark_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/ianwhite/hark
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Hark is a gem that enables  writing code in a "hexagonal architecture" or
+  "tell don't ask" style
+test_files:
+- spec/hark_spec.rb
+- spec/spec_helper.rb