clingfilm 0.4.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NjZjM2NjMDYzZjhlYjYxMjBmMGVkM2E4NzE3N2E3OWYwNjEyNTRhZA==
+  data.tar.gz: !binary |-
+    ODdkYTA5ZDRhNTcwMDBhNmIwNmRlYTkzODY3YjI5MWRmODEzNWU1Nw==
+SHA512:
+  metadata.gz: !binary |-
+    MzJjNzYwOGRjNmVmZjc5NmM4MDQzMWU0OWZkNjg1MTI2MmU5OWJiZjgzOTdk
+    MzU5ZmMzZTQ5NzAyOTBiN2Y3M2VlZThhNGVkMDQxNjhjZDY1MGM0M2JhZTc4
+    NDVmM2RiZWYyN2RjOTY4YTE0YzQyYTk4NTVlODBiMjZmZTYxYmM=
+  data.tar.gz: !binary |-
+    NGE5ZGQ2ZjYzOTk2NGRkZWFlMTAwMTliYWQ4ODllZjBlMjJiZmE1NmRmM2M1
+    NzU3ZTJmZjVlNjAzMWMwYzE0MTQ2NzM2ODc3NTRmYzg0M2QwMWY4ODMxNDc2
+    ZTA3YTk3ZDVkNmUwZWJmZDQ0YjliZGU2MGU1MjFkZWQ0OGM1YWY=

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+*.swo
+*.swp
+log
+tags
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--require support/spec_helper
+--colour

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create --install ruby-1.9.3-p429@hollywood

data/Gemfile

@@ -0,0 +1,17 @@
+source "https://rubygems.org"
+
+gem 'celluloid'
+
+group :test, :development do
+  gem 'logging'
+  gem 'metric_fu'
+  gem 'rake'
+  gem 'rspec'
+  gem 'simplecov'
+end
+
+group :development do
+  gem 'guard'
+  gem 'guard-bundler'
+  gem 'guard-rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,156 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    arrayfields (4.9.0)
+    atomic (1.1.14)
+    awesome_print (1.2.0)
+    bluff (0.1.0)
+    cane (2.6.0)
+      parallel
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    chronic (0.10.2)
+    churn (0.0.34)
+      chronic (>= 0.2.3)
+      hirb
+      json_pure
+      main
+      ruby_parser (~> 3.0)
+      sexp_processor (~> 4.1)
+    code_analyzer (0.4.3)
+      sexp_processor
+    code_metrics (0.1.1)
+    coderay (1.0.9)
+    colored (1.2)
+    diff-lcs (1.2.4)
+    erubis (2.7.0)
+    fattr (2.2.1)
+    ffi (1.9.0)
+    flay (2.4.0)
+      ruby_parser (~> 3.0)
+      sexp_processor (~> 4.0)
+    flog (4.1.2)
+      ruby_parser (~> 3.1, > 3.1.0)
+      sexp_processor (~> 4.0)
+    formatador (0.2.4)
+    guard (1.8.3)
+      formatador (>= 0.2.4)
+      listen (~> 1.3)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      thor (>= 0.14.6)
+    guard-bundler (1.0.0)
+      bundler (~> 1.0)
+      guard (~> 1.1)
+    guard-rspec (3.1.0)
+      guard (>= 1.8)
+      rspec (~> 2.13)
+    hirb (0.7.1)
+    i18n (0.6.5)
+    json_pure (1.8.0)
+    listen (1.3.1)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+      rb-kqueue (>= 0.2)
+    little-plugger (1.1.3)
+    logging (1.8.1)
+      little-plugger (>= 1.1.3)
+      multi_json (>= 1.3.6)
+    lumberjack (1.0.4)
+    main (5.2.0)
+      arrayfields (>= 4.7.4)
+      chronic (>= 0.6.2)
+      fattr (>= 2.2.0)
+      map (>= 5.1.0)
+    map (6.5.1)
+    method_source (0.8.2)
+    metric_fu (4.4.4)
+      bluff
+      cane (~> 2.5, >= 2.5.2)
+      churn (~> 0.0.28)
+      code_metrics (~> 0.1)
+      coderay
+      flay (~> 2.1, >= 2.0.1)
+      flog (~> 4.1, >= 4.1.1)
+      metric_fu-Saikuro (>= 1.1.1.0)
+      multi_json
+      rails_best_practices (~> 1.14, >= 1.14.3)
+      redcard
+      reek (~> 1.3, >= 1.3.3)
+      roodi (~> 3.1)
+    metric_fu-Saikuro (1.1.1.0)
+    minitest (4.7.5)
+    multi_json (1.8.1)
+    parallel (0.8.4)
+    pry (0.9.12.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rails_best_practices (1.14.4)
+      activesupport
+      awesome_print
+      code_analyzer (>= 0.4.3)
+      colored
+      erubis
+      i18n
+      require_all
+      ruby-progressbar
+    rake (10.1.0)
+    rb-fsevent (0.9.3)
+    rb-inotify (0.9.2)
+      ffi (>= 0.5.0)
+    rb-kqueue (0.2.0)
+      ffi (>= 0.5.0)
+    redcard (1.1.0)
+    reek (1.3.4)
+      ruby2ruby (~> 2.0.2)
+      ruby_parser (~> 3.2)
+      sexp_processor
+    require_all (1.3.1)
+    roodi (3.1.1)
+      ruby_parser (~> 3.2, >= 3.2.2)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    ruby-progressbar (1.2.0)
+    ruby2ruby (2.0.6)
+      ruby_parser (~> 3.1)
+      sexp_processor (~> 4.0)
+    ruby_parser (3.2.2)
+      sexp_processor (~> 4.1)
+    sexp_processor (4.3.0)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    slop (3.4.6)
+    thor (0.18.1)
+    thread_safe (0.1.3)
+      atomic
+    timers (1.1.0)
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  celluloid
+  guard
+  guard-bundler
+  guard-rspec
+  logging
+  metric_fu
+  rake
+  rspec
+  simplecov

data/Guardfile

@@ -0,0 +1,30 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  # Uncomment next line if Gemfile contain `gemspec' command
+  # watch(/^.+\.gemspec/)
+end
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Adam Whittingham
+
+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,39 @@
+Clingfilm
+=========
+A nice place for your Ruby actors to live
+-----------------------------------------
+
+Clingfilm is light system for concurrency on top of the wonderful [Celluloid](http://celluloid.io/) project. 
+Its goal is to be a quick & simple way to make use of the actor pattern in Ruby.
+
+Installation
+------------
+* Install the gem or add `gem "clingfilm"` to your Gemfile
+
+Usage
+-----
+Clingfilm is made up of 3 main components: MessageWrappers, Pulses and Marshallers.
+
+### Message Wrappers
+These wrap any Ruby object which has an "update" method and turns it into an actor. They listen on one or more queues for :update messages, run the update method and announce on the outgoing queues when they are done.
+
+### Pulses
+These are very basic actors which 'pulse' update messages on a given interval. Useful (if slightly inaccurate) clocks for getting things going!
+
+### Marshallers
+These deal with the construction and wiring up of the other elements. They also recreate any actors which explode due to exceptions.
+
+Logging
+-------
+Clingfilm publishes log messages about the sending and receiving of messages between actors at the debug level.
+The logging is done using Celluloids logging mechanism, which is null unless set; for example, in Rails:
+```
+Celluloid.logger = Rails.logger
+```
+More details can be read in the [Celluloid logging docs](https://github.com/celluloid/celluloid/wiki/Logging).
+
+ToDo
+----
+1. Allow sending data in messages instead of relying on store/retreive
+2. Add an example implementation to the documentation
+3. Add an more in-depth example implementation to the documentation

data/Rakefile

@@ -0,0 +1,6 @@
+$:.unshift "lib"
+require 'rubygems'
+require 'rake/clean'
+require 'bundler/setup'
+
+Dir.glob('build/tasks/*.rake').each { |r| import r }

data/build/tasks/cleanup.rake

@@ -0,0 +1,5 @@
+namespace :logs do
+  task :cleanup do
+    FileUtils.rm_rf('log/raw_data')
+  end
+end

data/build/tasks/coverage.rake

@@ -0,0 +1,14 @@
+begin
+  require "simplecov"
+
+  namespace :coverage do
+    task :check_specs do
+      SimpleCov.coverage_dir 'log/coverage/rspec'
+      coverage = SimpleCov.result.covered_percent
+      fail "Spec coverage was only #{coverage}%" if coverage < 100.0
+    end
+  end
+
+rescue LoadError
+  $stderr.puts 'Warning: SimpleCov not available.'
+end

data/build/tasks/default.rake

@@ -0,0 +1,14 @@
+require "rake/clean"
+
+task :default => [:spec, :'coverage:check_specs', :ok]
+
+task :ok do
+  red    = "\e[31m"
+  yellow = "\e[33m"
+  green  = "\e[32m"
+  blue   = "\e[34m"
+  purple = "\e[35m"
+  bold   = "\e[1m"
+  normal = "\e[0m"
+  puts "", "#{bold}#{red}*#{yellow}*#{green}*#{blue}*#{purple}*#{green} ALL TESTS PASSED #{purple}*#{blue}*#{green}*#{yellow}*#{red}*#{normal}"
+end

data/build/tasks/rspec.rake

@@ -0,0 +1,20 @@
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  RSpec::Core::RakeTask.new(:'spec:unit') do |t|
+    t.pattern = "spec/unit/**/*_spec.rb"
+  end
+
+  RSpec::Core::RakeTask.new(:'spec:int') do |t|
+    t.pattern = "spec/integration/**/*_spec.rb"
+  end
+
+  RSpec::Core::RakeTask.new(:rcov) do |t|
+    t.rcov = true
+    t.rcov_opts = %w{--exclude osx\/objc,gems\/,spec\/}
+  end
+rescue LoadError
+  $stderr.puts 'Warning: RSpec not available.'
+end

data/clingfilm.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "clingfilm"
+  spec.version       = '0.4.0'
+  spec.authors       = ["Adam Whittingham"]
+  spec.email         = ["adam.whittingham@gmail.com"]
+  spec.description   = %q{A light and easy way of working concurrently with Ruby, built on top of Celluloid}
+  spec.summary       = %q{A light, thin wrapper made of Celluloid}
+  spec.homepage      = "http://github.com/AdamWhittingham/clingfilm"
+  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|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "celluloid", ">= 0.14.0"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/clingfilm.rb

@@ -0,0 +1,3 @@
+require_relative 'clingfilm/messaging_wrapper'
+require_relative 'clingfilm/marshaller'
+require_relative 'clingfilm/pulse'

data/lib/clingfilm/marshaller.rb

@@ -0,0 +1,11 @@
+require 'celluloid'
+require 'celluloid/autostart'
+
+require_relative 'messaging_wrapper'
+require_relative 'pulse'
+
+module Clingfilm
+  class Marshaller < Celluloid::SupervisionGroup
+    alias_method :stop, :finalize
+  end
+end

data/lib/clingfilm/messaging_wrapper.rb

@@ -0,0 +1,53 @@
+require 'celluloid'
+
+module Clingfilm
+  class MessagingWrapper
+    include Celluloid
+    include Celluloid::Notifications
+    include Celluloid::Logger
+
+    attr_reader :exception, :channel
+
+    def initialize content, input_channels, output_channel
+      bounce_if_invalid content
+      @content = content
+      Array(input_channels).each{|channel| depends_on channel}
+      updates output_channel
+    end
+
+    def wraps
+      @content
+    end
+
+    def handle_message(channel, message)
+      info  "<- #{channel}"
+      debug "<< #{channel} = #{message}"
+      result = @content.update(message)
+      announce_updated(result) if result
+    end
+
+    def announce_updated message
+      publish(@channel, message)
+      info  "-> #{@channel}"
+      debug ">> #{@channel} = #{message}"
+    end
+
+    def depends_on channel
+      subscribe(channel, :handle_message)
+    end
+
+    def updates channel
+      @channel = channel
+    end
+
+    def to_s
+      "#{self.class}[#{@content.class}]"
+    end
+
+    private
+
+    def bounce_if_invalid content
+      raise "Cannot wrap an object which doesn't provide #update" unless content.respond_to? 'update'
+    end
+  end
+end

data/lib/clingfilm/pulse.rb

@@ -0,0 +1,26 @@
+require 'celluloid'
+
+module Clingfilm
+  class Pulse
+    DEFAULT_INTERVAL = 600
+    include Celluloid
+    include Celluloid::Notifications
+    include Celluloid::Logger
+
+    attr_reader :channel
+
+    def initialize(channel, options = {})
+      @channel = channel
+      interval = options.fetch :interval, DEFAULT_INTERVAL
+      unless ENV["DISABLE_CLINGFILM_PULSES"]
+        every(interval) { pulse }
+        pulse
+      end
+    end
+
+    def pulse
+      publish @channel, :update
+      debug "update -> #{@channel}"
+    end
+  end
+end

data/spec/clingfilm/marshaller_spec.rb

@@ -0,0 +1,57 @@
+require 'timeout'
+require production_code
+
+class Foo; def update; end; end
+
+describe Clingfilm::Marshaller, :celluloid do
+
+  subject{ Clingfilm::Marshaller.run! }
+
+  before(:each) do
+    @actors = ActorHelper.new
+  end
+
+  context "when an actor is being supervised" do
+    before do
+      Clingfilm::Marshaller.supervise Clingfilm::MessagingWrapper,
+          as: :an_actor,
+          args: [Foo.new, 'test_channel_in', 'test_channel_out']
+      subject
+    end
+
+    describe '#stop' do
+      it 'terminates the actors' do
+        @actors[:an_actor].should be_alive
+
+        subject.stop
+        Timeout::timeout(10) do
+          sleep 0.01 while @actors[:an_actor] && @actors[:an_actor].alive?
+        end
+
+        actor = @actors[:an_actor]
+        if actor
+          expect(actor).to_not be_alive
+        else
+          expect(actor).to be_nil
+        end
+      end
+    end
+
+    context 'when an actor crashes' do
+      it 'restarts the actor' do
+        expect { @actors[:an_actor].crash_me }.to raise_error
+        loop do
+          sleep 0.1
+          break if @actors[:an_actor].class != NilClass
+        end
+        expect(@actors[:an_actor]).to be_alive
+      end
+
+      it 'logs the crash' do
+        expect { @actors[:an_actor].crash_me }.to raise_error
+        expect(log_output).to include "MessagingWrapper crashed!"
+      end
+
+    end
+  end
+end

data/spec/clingfilm/messaging_wrapper_spec.rb

@@ -0,0 +1,113 @@
+require production_code
+require 'support/messaging_helper'
+require 'support/celluloid_hooks'
+
+describe Clingfilm::MessagingWrapper, :celluloid do
+  let(:wrapped)        { double "wrapped",  { :update => true } }
+  let(:input_channel)  { "input_channel" }
+  let(:other_channel)  { "other_channel" }
+  let(:output_channel) { "output_channel" }
+  let(:some_data)      { double "some data" }
+  let!(:listener)      { MessageHelper.new(output_channel) }
+
+  subject! { Clingfilm::MessagingWrapper.new(wrapped, input_channel, output_channel) }
+
+  describe '#new' do
+    it 'throws an exception if the wrapped object does not respond to #update' do
+      expect { Clingfilm::MessagingWrapper.new( double('un-updateable'), input_channel, output_channel)}.to raise_error "Cannot wrap an object which doesn't provide #update"
+    end
+
+    it 'can optionally be created with multiple input channels' do
+      Clingfilm::MessagingWrapper.new(wrapped, ['input_1', 'input_2'], output_channel)
+      MessageHelper.new.publish('input_1', :updated)
+      MessageHelper.new.publish('input_2', :updated)
+      expect(wrapped).to have_received(:update).twice
+    end
+  end
+
+  describe '#to_s' do
+    it 'mentions the wrapped class' do
+      expect(subject.to_s).to eq "Clingfilm::MessagingWrapper[#{wrapped.class}]"
+    end
+  end
+
+  describe "#wraps" do
+    it 'wraps the given object' do
+      expect(subject.wraps).to eq wrapped
+    end
+  end
+
+  describe "messaging" do
+    describe "incomming" do
+      it 'calls wrapped#update when receiving a message on a subscribed channel' do
+        MessageHelper.new.publish(input_channel, :update)
+        expect(wrapped).to have_received :update
+      end
+
+      it 'does not update for messages on non-subscribed channels' do
+        MessageHelper.new.publish(other_channel, :update)
+        expect(wrapped).to_not have_received :update
+      end
+
+      it 'can subscribe to multiple input channels' do
+        subject.depends_on 'foo'
+        MessageHelper.new.publish('input_channel', :updated)
+        MessageHelper.new.publish('foo', :updated)
+        expect(wrapped).to have_received(:update).twice
+      end
+
+    end
+
+    describe "outgoing" do
+      it 'announces the return of wrapper#update on the output channel' do
+        wrapped.stub(update: some_data)
+        MessageHelper.new.publish(input_channel, :update)
+        expect(listener.messages).to include [output_channel, some_data]
+      end
+
+      it 'does not announce if the wrapped object returns nil' do
+        wrapped.stub(update: nil)
+        MessageHelper.new.publish(input_channel, :update)
+        expect(listener).to_not be_updated
+      end
+
+      it 'dies if the wrapped class exceptions' do
+        wrapped.stub(:update){raise 'some error'}
+        MessageHelper.new.publish(input_channel, :update)
+        expect(subject).to_not be_alive
+      end
+    end
+  end
+
+  describe 'logging' do
+    context "at the INFO level" do
+      it 'logs when it announces' do
+        wrapped.stub(update: :output)
+        MessageHelper.new.publish(input_channel, :update)
+        sleep 0.1
+        log_output.should include "INFO Celluloid : -> #{output_channel}"
+      end
+
+      it 'logs when a message is received' do
+        MessageHelper.new.publish(input_channel, :update)
+        sleep 0.1
+        log_output.should include "INFO Celluloid : <- #{input_channel}"
+      end
+    end
+
+    context "at the DEBUG level" do
+      it 'logs what it announces' do
+        MessageHelper.new.publish(input_channel, :update)
+        sleep 0.1
+        log_output.should include "DEBUG Celluloid : >> #{output_channel} = true"
+      end
+
+      it 'logs the messages are received' do
+        MessageHelper.new.publish(input_channel,:update)
+        sleep 0.1
+        log_output.should include "DEBUG Celluloid : << #{input_channel} = update"
+      end
+    end
+
+  end
+end

data/spec/clingfilm/pulse_spec.rb

@@ -0,0 +1,34 @@
+require 'support/messaging_helper'
+require production_code
+
+describe Clingfilm::Pulse, :celluloid do
+  let!(:receiver) {MessageHelper.new 'foo'}
+
+  before { ENV.delete "DISABLE_CLINGFILM_PULSES" }
+  after { receiver.reset }
+
+  it 'publishes an update message shortly after startup' do
+    Clingfilm::Pulse.new 'foo'
+    sleep 0.1
+    expect(receiver.message_count).to eq 1
+  end
+
+  it 'publishes update messages for a given channel every x seconds' do
+    Clingfilm::Pulse.new 'foo', interval: 1
+    sleep 1.1
+    expect(receiver.message_count).to eq 2
+  end
+
+  it "does not pulse if ENV['DISABLE_CLINGFILM_PULSES'] is set" do
+    ENV["DISABLE_CLINGFILM_PULSES"] = "true"
+    Clingfilm::Pulse.new 'foo'
+    sleep 0.2
+    expect(receiver.message_count).to eq 0
+  end
+
+  it 'logs when it sends a pulse' do
+    Clingfilm::Pulse.new 'foo'
+    sleep 0.1
+    expect(log_output).to include "update -> foo"
+  end
+end

data/spec/support/actor_helper.rb

@@ -0,0 +1,17 @@
+require "celluloid"
+
+class ActorHelper
+  include Celluloid
+
+  def [](name)
+    Celluloid::Actor[name]
+  end
+end
+
+module Clingfilm
+  class MessagingWrapper
+    def crash_me message= 'Crashed by tests!'
+      raise message
+    end
+  end
+end

data/spec/support/celluloid_hooks.rb

@@ -0,0 +1,13 @@
+require 'celluloid'
+require 'logging'
+
+Celluloid.logger = Logging.logger.new(Celluloid.to_s)
+Celluloid.shutdown_timeout = 1
+
+# Reboot celluloid; ESSENTIAL in avoiding state overflowing between tests
+RSpec.configure do |config|
+	config.before(:each, celluloid: true) do
+		Celluloid.shutdown
+		Celluloid.boot
+	end
+end

data/spec/support/coverage_helper.rb

@@ -0,0 +1,4 @@
+SimpleCov.coverage_dir 'log/coverage/rspec'
+SimpleCov.start do
+	add_filter '/spec/'
+end

data/spec/support/logging_helper.rb

@@ -0,0 +1,12 @@
+require 'logging'
+require 'rspec/logging_helper'
+
+RSpec.configure do |config|
+  include RSpec::LoggingHelper
+  config.capture_log_messages
+end
+
+def log_output
+  fail "No log output found" unless @log_output
+  @log_output.readlines.map{|s|s.strip.squeeze(" ")}.join "\n"
+end

data/spec/support/messaging_helper.rb

@@ -0,0 +1,28 @@
+require "celluloid"
+
+class MessageHelper
+  include Celluloid
+  include Celluloid::Notifications
+  attr_reader :has_updated, :messages
+
+  def initialize channel='default'
+    @messages = []
+    subscribe(channel, :handle_message)
+  end
+
+  def message_count
+    @messages.size
+  end
+
+  def handle_message (channel, message)
+    @messages << [channel, message]
+  end
+
+	def updated?
+		message_count > 0
+	end
+
+  def reset
+    @has_updated = false
+  end
+end

data/spec/support/spec_helper.rb

@@ -0,0 +1,20 @@
+$:.unshift 'lib'
+
+require 'bundler/setup'
+require "simplecov" # Needs to be done first
+
+require_relative 'logging_helper'
+require_relative 'actor_helper'
+require_relative 'coverage_helper'
+require_relative 'celluloid_hooks'
+
+def production_code
+  spec = caller[0][/spec.+\.rb/]
+  './' + spec.gsub('_spec','').gsub(/spec\//, 'lib/')
+end
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end
+

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: clingfilm
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Adam Whittingham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+- !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'
+description: A light and easy way of working concurrently with Ruby, built on top
+  of Celluloid
+email:
+- adam.whittingham@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- build/tasks/cleanup.rake
+- build/tasks/coverage.rake
+- build/tasks/default.rake
+- build/tasks/rspec.rake
+- clingfilm.gemspec
+- lib/clingfilm.rb
+- lib/clingfilm/marshaller.rb
+- lib/clingfilm/messaging_wrapper.rb
+- lib/clingfilm/pulse.rb
+- spec/clingfilm/marshaller_spec.rb
+- spec/clingfilm/messaging_wrapper_spec.rb
+- spec/clingfilm/pulse_spec.rb
+- spec/support/actor_helper.rb
+- spec/support/celluloid_hooks.rb
+- spec/support/coverage_helper.rb
+- spec/support/logging_helper.rb
+- spec/support/messaging_helper.rb
+- spec/support/spec_helper.rb
+homepage: http://github.com/AdamWhittingham/clingfilm
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A light, thin wrapper made of Celluloid
+test_files:
+- spec/clingfilm/marshaller_spec.rb
+- spec/clingfilm/messaging_wrapper_spec.rb
+- spec/clingfilm/pulse_spec.rb
+- spec/support/actor_helper.rb
+- spec/support/celluloid_hooks.rb
+- spec/support/coverage_helper.rb
+- spec/support/logging_helper.rb
+- spec/support/messaging_helper.rb
+- spec/support/spec_helper.rb