dilation 0.0.2

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,2 @@
+--colour
+--format progress

data/.yardopts

@@ -0,0 +1,4 @@
+--no-private
+--hide-void-return
+-
+LICENSE

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dilation.gemspec
+gemspec
+
+gem 'yard', :require => nil
+gem 'redcarpet', :require => nil
+
+group :extras do
+  gem 'pry'
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jim Deville
+
+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,122 @@
+# Dilation
+
+A timer that provides an event based interface to hook into for your app. In addition, the back end timer can be swapped out, so for testing, you can control the passage of time.  
+
+## Synopsis
+
+``` ruby
+require 'rubygems'
+require 'dilation'
+
+class WakeHandler
+  def call
+    puts 'awake'
+  end
+end
+
+def stop_handler
+  puts 'stop'
+end
+
+c = Dilation::Core.new
+
+trap 'INT' do
+  c.stop
+  abort
+end
+
+c.listen_for :start do puts 'start' end
+c.listen_for :stop, method(:stop_handler)
+c.listen_for :sleep, lambda { puts 'sleep' }
+c.listen_for :wake, WakeHandler.new
+c.listen_for :tick, lambda { puts 'tick' }
+
+puts 'sleeping'
+
+c.sleep 5
+
+puts 'starting'
+counter = 0
+
+c.listen_for :tick, lambda { counter += 1 }
+
+c.start
+while counter < 5
+end
+
+c.stop
+
+puts 'ok'
+```
+
+TODO
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dilation'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dilation
+
+## Usage
+
+The [rubydoc.info docs](http://rubydoc.info/gems/dilation/frames) contain
+API documentation. The API docs contain detailed info about all of Dilation's public API.
+
+## Release Policy
+
+Dilation follows the principles of [semantic versioning](http://semver.org/).
+The [API documentation](http://rubydoc.info/gems/dilation/frames) define
+Dilation's public API.  Patch level releases contain only bug fixes.  Minor
+releases contain backward-compatible new features.  Major new releases
+contain backwards-incompatible changes to the public API.
+
+## Ruby Interpreter Compatibility
+
+Dilation has been tested on the following ruby interpreters:
+
+* MRI 1.9.2
+
+## Development
+
+* Source hosted on [GitHub](http://github.com/jredville/dilation).
+* Report issues on [GitHub Issues](http://github.com/jredville/dilation/issues).
+* Pull requests are very welcome! Please include spec and/or feature coverage for every patch,
+  and create a topic branch for every separate change you make.
+* Documentation is generated with [YARD](http://yardoc.org/) ([cheat sheet](http://cheat.errtheblog.com/s/yard/)).
+  To generate while developing:
+
+```
+yard server --reload
+```
+
+## Todo
+
+* Better interface to swap backend
+* dilation/test_support
+* [Code Climate](http://codeclimate.com)
+* [Travis](http://travis-ci.org/)
+** test on interpreters
+*** 1.8.7
+*** 1.9.3
+*** REE
+*** Rubinius
+* make Celluloid optional
+* ability to override Kernel#sleep
+
+## Thanks
+
+* [Myron Marston](http://github.com/myronmarston) for [VCR](http://github.com/myronmarston/vcr), which wasn't used here, but influences how I want to run this project and this readme.
+* [Microsoft's Reactive Extensions](http://msdn.microsoft.com/en-us/data/gg577609.aspx) team for the idea of [controlling the flow of time](http://channel9.msdn.com/Shows/Going+Deep/Wes-Dyer-and-Jeffrey-Van-Gogh-Inside-Rx-Virtual-Time)
+
+## Copyright
+
+Copyright (c) 2010-2012 Jim Deville. Released under the terms of the
+MIT license. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  # Put spec opts in a file named .rspec in root
+end
+
+task :default => :spec

data/dilation.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/dilation/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "dilation"
+  gem.authors       = ["Jim Deville"]
+  gem.email         = ["james.deville@gmail.com"]
+  gem.description   = %q{A controllable timer}
+  gem.summary       = %q{A timer that provides an event based interface to hook into for your app. In addition, the back end timer can be swapped out, so for testing, you can control the passage of time.}
+  gem.homepage      = "http://github.com/jredville/dilation"
+
+  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.version       = Dilation::VERSION
+  gem.platform = Gem::Platform::RUBY
+  gem.required_ruby_version = '>= 1.9.2'
+  gem.required_rubygems_version = '>= 1.3.5'
+
+  gem.add_dependency('celluloid')
+  gem.add_development_dependency('rake', '~> 0.9.2')
+  gem.add_development_dependency('rspec')
+end

data/lib/dilation.rb

@@ -0,0 +1,17 @@
+require "dilation/version"
+require "dilation/core"
+
+# Top level namespace for Dilation
+# @see Dilation::Core
+#
+# @author Jim Deville <james.deville@gmail.com>
+module Dilation
+  # Contains classes to be used for tests
+  module TestSupport end
+
+  # Contains timers for the backend of Core
+  module Timers end
+
+  # Utility classes that support the implementation
+  module Utils end
+end

data/lib/dilation/core.rb

@@ -0,0 +1,135 @@
+require_relative 'utils/events'
+require_relative 'utils/dilator'
+require_relative 'timers/coarse'
+
+module Dilation
+  # Dilation::Core is the main object that allows you to interact
+  # with and test timers.
+  #
+  # @author Jim Deville <james.deville@gmail.com>
+  # @todo better interface to swap the timer
+  class Core
+    include Utils::Events
+    event :tick, :start, :stop, :sleep, :wake
+
+    # @param [#call] value The factory for the timer
+    attr_writer :timer_source
+
+    def initialize
+      @dilator = Utils::Dilator.new
+    end
+
+    # Slows down (dilates) time for your code
+    #
+    # @example Run at half time
+    #   core.dilate(2)
+    #   core.tick #=> nothing
+    #   core.tick #=> fires tick event
+    #
+    # @overload dilate
+    #   Sets a factor of 1 which is the same as no dilation
+    # @overload dilate(factor)
+    #   Sets a factor of `factor` which implies one `Core#tick` per
+    #     `factor` `Core#timer` ticks
+    #   @param [Number] factor the dilation factor
+    # @return [Number] the dilation factor
+    # @see Dilation::Utils::Dilator
+    def dilate(factor = 1)
+      @dilator.factor = factor
+      @dilator.invert
+      factor
+    end
+
+    # Speeds up (contracts) time for your code
+    #
+    # @example Run at 2x time
+    #   core.contract(2)
+    #   core.tick #=> fires 2 tick events
+    #
+    # @overload contract
+    #   Sets a factor of 1 which is the same as no contraction
+    # @overload contract(factor)
+    #   Sets a factor of `factor` which implies `factor` `Core#tick`s
+    #     per one `Core#timer` tick
+    #   @param [Number] factor the contraction factor
+    # @return [Number] the contraction factor
+    # @see Dilation::Utils::Dilator
+    def contract(factor = 1)
+      @dilator.factor = factor
+      @dilator.uninvert
+      factor
+    end
+
+    # @private
+    # Called by the timer on each tick. Fires tick events based on
+    #   the dilation/contraction factor
+    #
+    # @see #dilate
+    # @see #contract
+    def tick
+      if started?
+        @dilator.run { __tick }
+      end
+    end
+
+    # Starts the timer and fires the start event
+    def start
+      timer.start
+      @started = true
+      __start
+    end
+
+    # Stops the timer and fires the stop event
+    def stop
+      timer.stop
+      @started = false
+      __stop
+    end
+
+    # Sleeps for `time` (based on Core#tick).
+    #
+    # @note This method blocks the caller
+    #
+    # @example Sleep for 5 seconds
+    #   core.sleep 5 #=> 5
+    # @example Sleep for 1 second
+    #   core.sleep #=> 1
+    # @overload sleep(time)
+    #   Sleep for the given number of second
+    #   @param [Number] time the time to sleep for in seconds
+    # @overload sleep
+    #   Sleep for 1 second
+    # @return [Number] time
+    def sleep(time=1)
+      sleep_handler = lambda { time -= 1}
+      listen_for :tick, sleep_handler
+      __sleep
+      start
+      while time > 0
+      end
+      stop
+      wake
+      time
+    ensure
+      dont_listen_for :tick, sleep_handler
+    end
+
+    # @return [Timer] the timer object for this core
+    #
+    # @see Dilation::Timers::Coarse
+    def timer
+      @timer ||= timer_source.call(self)
+    end
+
+    # @todo does this need to be public?
+    # @return [Boolean] is this core started or not
+    def started?
+      defined?(@started) && @started
+    end
+
+    private
+    def timer_source
+      @timer_source ||= lambda { |obj| Timers::Coarse.new(obj) }
+    end
+  end
+end

data/lib/dilation/test_support/handler.rb

@@ -0,0 +1,40 @@
+module Dilation
+  module TestSupport
+    # A handler that can be used in tests to confirm that events are hooked up
+    #
+    # @example Rspec example
+    #   describe "Example" do
+    #     let(:handler) { Dilation::TestSupport::Handler.new }
+    #     subject { MyCoreBasedClass.new }
+    #
+    #     it "triggers handler" do
+    #       subject.listen_for :tick, handler
+    #       subject.tick
+    #       handler.should be_triggered
+    #     end
+    #   end
+    #
+    # @author Jim Deville <james.deville@gmail.com>
+    class Handler
+      # @return [Number] the number of times triggered
+      attr_reader :count
+
+      def initialize
+        @count = 0
+      end
+
+      # Trigger this handler
+      # @note increments the counter
+      #
+      # @return [Number] the new count
+      def call
+        @count += 1
+      end
+
+      # @return [Boolean] true if this handler has been called
+      def triggered?
+        @count > 0
+      end
+    end
+  end
+end

data/lib/dilation/timers/coarse.rb

@@ -0,0 +1,28 @@
+require 'celluloid'
+require_relative 'timer'
+
+Celluloid.logger = nil
+
+module Dilation
+  module Timers
+    # A Celluloid based timer that is the default for Dilation::Core
+    # @see http://celluloid.io/
+    #
+    # @author Jim Deville <james.deville@gmail.com>
+    class Coarse < Timer
+      include Celluloid
+
+      # Stop this timer
+      def stop
+        defined?(@timer) && @timer.cancel
+        super
+      end
+
+      # Start this timer, ticking every second
+      def start
+        @timer = every(1) { tick }
+        super
+      end
+    end
+  end
+end

data/lib/dilation/timers/test.rb

@@ -0,0 +1,13 @@
+require_relative 'timer'
+
+module Dilation
+  module Timers
+    # A test timer that does not fire by itself. Primarily meant to
+    # be used inside of tests so you can control the passage of time
+    #
+    # @author Jim Deville <james.deville@gmail.com>
+    # @todo make this default for tests
+    class Test < Timer
+    end
+  end
+end

data/lib/dilation/timers/timer.rb

@@ -0,0 +1,33 @@
+module Dilation
+  module Timers
+    # @abstract Subclass and override {#start} and {#stop}
+    #
+    # @author Jim Deville <james.deville@gmail.com>
+    class Timer
+      # @param [#tick] target the object to notify on ticks
+      def initialize(target)
+        @target = target
+      end
+
+      # This method should be called by subclasses on each tick
+      def tick
+        @target.tick
+      end
+
+      # @return [Boolean] true if this timer is running
+      def running?
+        defined?(@started) && @started
+      end
+
+      # Stop this timer
+      def stop
+        @started = false
+      end
+
+      # Start this timer
+      def start
+        @started = true
+      end
+    end
+  end
+end

data/lib/dilation/utils/dilator.rb

@@ -0,0 +1,80 @@
+module Dilation
+  module Utils
+    # This class is used for controlling the dilation and contraction
+    # factors of Core
+    #
+    # @author Jim Deville <james.deville@gmail.com>
+    # @todo Fix floating point issue (see specs)
+    class Dilator
+      def initialize
+        self.factor = 1
+      end
+
+      # Set the factor and reset the dilator
+      #
+      # @param [Number] val the new factor
+      def factor=(val)
+        @factor = val
+        reset
+      end
+
+      # Invert the dilator. When inverted, `factor` calls to {#run}
+      # yield once. Also resets the dilator
+      #
+      # @see {#run}
+      def invert
+        @invert = true
+        reset
+      end
+
+      # Uninvert the dilator. When uninverted, one call to {#run}
+      # yield `factor` times. Also resets the dilator
+      #
+      # @see {#run}
+      def uninvert
+        @invert = false
+        reset
+      end
+
+      # @return [Boolean] true if this dilator is inverted
+      def inverted?
+        defined?(@invert) && @invert
+      end
+
+      # Reset this dilator
+      # @todo should this be public?
+      def reset
+        @count = 0
+      end
+
+      # Run ths dilator based on the factor
+      #
+      # @yield if the factor is met
+      # @see {#invert}
+      # @see {#uninvert}
+      def run(&blk)
+        begin
+          blk.call
+        end while run_again? if ready?
+      end
+
+      private
+      def ready?
+        @count += factor
+        @count >= 1
+      end
+
+      def factor
+        @invert ? 1/@factor.to_f : @factor
+      end
+
+      def run_again?
+        @count -= 1
+        if @count < 1
+          return false
+        end
+        true
+      end
+    end
+  end
+end

data/lib/dilation/utils/events.rb

@@ -0,0 +1,91 @@
+module Dilation
+  module Utils
+    # Defines an event handler system loosely based off of the DOM
+    # addEventListener pattern
+    #
+    # @example
+    #   class Foo
+    #     include Dilation::Utils::Events
+    #     event :bar, :baz
+    #     def baz
+    #       bar
+    #       __baz
+    #     end
+    #   end
+    #   f = Foo.new
+    #   f.listen_for :bar, { puts 'bar' }
+    #   f.listen_for :baz, { puts 'baz' }
+    #   f.baz #=> prints bar then baz
+    #
+    # @author Jim Deville <james.deville@gmail.com>
+    # @todo fix return types
+    module Events
+      # @private
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+
+      module ClassMethods
+        # Defines one or more events with the name and the __name variant
+        #
+        # @param [Array<String>, Array<Symbol>] names the names of the events to create
+        def event(*names)
+          names.each do |name|
+            define_method(name) { fire name }
+            alias_method :"__#{name}", name
+          end
+        end
+      end
+
+      # Registers a block or callable for the given event
+      #
+      # @overload listen_for(name, handler)
+      #   registers the handler for the event
+      #   @param [String, Symbol, #to_sym] name the event to listen for
+      #   @param [#call] handler the handler to trigger for this event
+      # @overload listen_for(name, &blk)
+      #   registers the block for the event
+      #   @param [String, Symbol, #to_sym] name the event to listen for
+      #   @param blk the block to trigger for this event
+      # @raise ArgumentError if handler or blk is not present
+      def listen_for(name, handler = nil, &blk)
+        to_add = handler || blk
+        raise ArgumentError.new "handler or block required" unless to_add
+        handlers[name.to_sym] << to_add
+      end
+
+      # Removes a callable for the given event
+      #
+      # @param [String, Symbol, #to_sym] name the event to remove from
+      # @param [#call] handler the handler to remove
+      def dont_listen_for(name, handler)
+        handlers[name.to_sym].delete(handler)
+      end
+
+      # Clears all handlers for the event
+      #
+      # @param [String, Symbol, #to_sym] name the event to clear
+      def clear(name)
+        handlers[name.to_sym] = []
+      end
+
+      # Clear all tracked handlers
+      def clear_all
+        self.handlers = Hash.new { |h, k| h[k] = [] }
+      end
+
+      # Triggers the given event
+      #
+      # @param [String, Symbol, #to_sym] name event to trigger
+      def fire(name)
+        handlers[name.to_sym].each(&:call)
+      end
+
+      private
+      attr_writer :handlers
+      def handlers
+        @handlers || clear_all
+      end
+    end
+  end
+end

data/lib/dilation/version.rb

@@ -0,0 +1,4 @@
+module Dilation
+  # The version of this library
+  VERSION = "0.0.2"
+end

data/spec/dilation/core_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_mini'
+require 'dilation/core'
+require 'dilation/timers/test'
+
+describe Dilation::Core do
+  let(:core) { Dilation::Core.new }
+  let(:timer) { Dilation::Timers::Test.new(subject) }
+
+  include_context "core event"
+
+  subject do
+    core.tap do |c|
+      c.timer_source = lambda { |o| timer }
+    end
+  end
+
+  context "starting and stopping" do
+    before do
+      subject.listen_for :tick, handler
+    end
+
+    it "starts timer when start is called" do
+      timer.should_receive(:start)
+      subject.start
+    end
+
+    it "stops timer when stop is called" do
+      timer.should_receive(:stop)
+      subject.stop
+    end
+
+    it "does not get ticks before timer is started" do
+      expect { timer.tick }.not_to trigger(handler)
+    end
+
+    it "gets ticks after timer is started" do
+      subject.start
+      expect { timer.tick }.to trigger(handler)
+    end
+
+    it "does not get ticks after timer is stopped" do
+      subject.start
+      subject.stop
+      expect { timer.tick }.not_to trigger(handler)
+    end
+
+    it "ignores multiple start calls"
+    it "ignores multiple stop calls"
+    it "stop when not started is ignored"
+  end
+
+  context "timer" do
+    before do
+      subject.start
+    end
+
+    it "gets tick called by the timer" do
+      subject.listen_for :tick, handler
+      expect { timer.tick }.to trigger(handler)
+    end
+  end
+
+  context "dilation" do
+    before do
+      subject.listen_for :tick, handler
+      subject.start
+    end
+
+    it "returns the new factor" do
+      subject.dilate.should == 1
+      subject.dilate(2).should == 2
+      subject.contract.should == 1
+      subject.contract(2).should == 2
+    end
+
+    it "receives one tick per tick of the timer by default" do
+      10.times { timer.tick }
+      handler.count.should == 10
+    end
+
+    it "dilates time" do
+      subject.dilate(2) #2 real ticks per tick
+      10.times { timer.tick }
+      handler.count.should == 5
+    end
+
+    it "defaults to a dilation factor of 1" do
+      subject.dilate
+      10.times { timer.tick }
+      handler.count.should == 10
+    end
+
+    it "contracts time" do
+      subject.contract(2) #2 ticks for every real tick
+      10.times { timer.tick }
+      handler.count.should == 20
+    end
+
+    it "defaults to a contraction factor of 1" do
+      subject.contract
+      10.times { timer.tick }
+      handler.count.should == 10
+    end
+
+    it "resets dilation with contraction" do
+      subject.dilate(2)
+      subject.contract(2)
+      10.times { timer.tick }
+      handler.count.should == 20
+    end
+
+    it "resets contraction with dilation" do
+      subject.contract(2)
+      subject.dilate(2)
+      10.times { timer.tick }
+      handler.count.should == 5
+    end
+  end
+
+  context "events" do
+    context "tick" do
+      before do
+        subject.start
+      end
+      it_behaves_like "a core event", :tick, :tick
+    end
+
+    context "start" do
+      it_behaves_like "a core event", :start, :start
+    end
+
+    context "stop" do
+      it_behaves_like "a core event", :stop, :stop
+    end
+
+    # context "sleep" do
+    #   it_behaves_like "a core event", :sleep, :sleep
+    # end
+
+    context "wake" do
+      it_behaves_like "a core event", :wake, :wake
+    end
+  end
+end

data/spec/dilation/utils/dilator_spec.rb

@@ -0,0 +1,85 @@
+require 'dilation/utils/dilator'
+
+describe Dilation::Utils::Dilator do
+  before do
+    @counter = 0
+    @blk = lambda { @counter += 1 }
+  end
+
+  shared_examples "an inverter" do
+    it "inverts" do
+      subject.invert
+      subject.should be_inverted
+    end
+
+    it "uninverts" do
+      subject.uninvert
+      subject.should_not be_inverted
+    end
+
+    it "defaults to 1 run per tick" do
+      expect { |b| subject.run(&b) }.to yield_control
+    end
+  end
+
+  context "when uninverted" do
+    it_behaves_like "an inverter"
+
+    it { subject.should_not be_inverted }
+
+    it "runs n times per tick if factor is set to n" do
+      subject.factor = 2
+      subject.run &@blk
+      @counter.should == 2
+    end
+
+    it "runs fractional factors" do
+      subject.factor = 1.5
+      subject.run &@blk
+      @counter.should == 1
+      subject.run &@blk
+      @counter.should == 3
+    end
+  end
+
+  context "when inverted" do
+    before do
+      subject.invert
+    end
+
+    it_behaves_like "an inverter"
+
+    it { subject.should be_inverted }
+
+    it "runs once every n times if factor is set to n and object is inverted" do
+      subject.factor = 3
+      3.times { subject.run &@blk }
+      @counter.should == 1
+    end
+
+    it "resets the count when factor is changed" do
+      subject.factor = 2
+      subject.run &@blk
+      subject.factor = 3
+      2.times { subject.run &@blk }
+      @counter.should == 0
+    end
+
+    it "runs fractional factors" do
+      pending "floating point issue"
+      subject.factor = 1.5
+      3.times { subject.run &@blk }
+      @counter.should == 2
+    end
+
+    it "resets the count when the inversion is changed" do
+      pending "floating point"
+      subject.invert
+      subject.factor = 1.5
+      subject.run &@blk
+      subject.invert
+      subject.run &@blk
+      @counter.should == 1
+    end
+  end
+end

data/spec/integration.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'dilation'
+
+class WakeHandler
+  def call
+    puts 'awake'
+  end
+end
+
+def stop_handler
+  puts 'stop'
+end
+
+c = Dilation::Core.new
+
+trap 'INT' do
+  c.stop
+  abort
+end
+
+c.listen_for :start do puts 'start' end
+c.listen_for :stop, method(:stop_handler)
+c.listen_for :sleep, lambda { puts 'sleep' }
+c.listen_for :wake, WakeHandler.new
+c.listen_for :tick, lambda { puts 'tick' }
+
+puts 'sleeping'
+
+c.sleep 5
+
+puts 'starting'
+counter = 0
+
+c.listen_for :tick, lambda { counter += 1 }
+
+c.start
+while counter < 5
+end
+
+c.stop
+
+puts 'ok'

data/spec/spec_mini.rb

@@ -0,0 +1,2 @@
+require_relative 'support/shared_examples'
+require_relative 'support/matchers'

data/spec/support/matchers.rb

@@ -0,0 +1,19 @@
+RSpec::Matchers.define(:trigger) do |handler|
+  match do |actual|
+    @not_to_trigger ||= []
+    @to_trigger ||= []
+    @to_trigger << handler
+    actual.call
+    @to_trigger.all?(&:triggered?) && @not_to_trigger.none?(&:triggered?)
+  end
+
+  chain :but_not do |handler|
+    @not_to_trigger ||= []
+    @not_to_trigger << handler
+  end
+
+  chain :and_also do |handler|
+    @to_trigger ||= []
+    @to_trigger << handler
+  end
+end

data/spec/support/shared_examples.rb

@@ -0,0 +1,69 @@
+require 'dilation/test_support/handler'
+
+shared_context "core event" do
+  let(:handler) { Dilation::TestSupport::Handler.new }
+  let(:handler2) { Dilation::TestSupport::Handler.new }
+end
+
+shared_examples "a core event" do |event_name, trigger|
+  it_behaves_like "a core event details", event_name, trigger
+  it_behaves_like "a core event details", event_name, "__#{trigger}"
+end
+
+shared_examples "a core event details" do |event_name, trigger|
+  include_context "core event"
+
+  it "can trigger without handlers" do
+    expect { subject.send trigger }.to_not raise_error
+  end
+
+  it "can be subscribed via #listen_for with :#{event_name}" do
+    subject.listen_for event_name, handler
+    expect { subject.send trigger }.to trigger(handler)
+  end
+
+  it "can be subscribed multiple times via #listen_for with :#{event_name}" do
+    subject.listen_for event_name, handler
+    subject.listen_for event_name.to_s, handler2
+    expect { subject.send trigger }.to trigger(handler).and_also(handler2)
+  end
+
+  it "listen_for requires a block or a handler" do
+    expect { subject.listen_for event_name }.to raise_error ArgumentError
+  end
+
+  it "listen_for ignores the block if a handler is given" do
+    subject.listen_for event_name, handler do
+      handler2.call
+    end
+    expect { subject.send trigger }.to trigger(handler).but_not(handler2)
+  end
+
+  it "can subscribe to a block" do
+    subject.listen_for event_name do
+      handler.call
+    end
+    expect { subject.send trigger }.to trigger(handler)
+  end
+
+  it "can clear a listener" do
+    subject.listen_for event_name, handler
+    subject.listen_for event_name, handler2
+    subject.dont_listen_for event_name, handler2
+    expect { subject.send trigger }.to trigger(handler).but_not(handler2)
+  end
+
+  it "works after clearing listeners" do
+    subject.listen_for event_name, handler
+    subject.clear event_name
+    subject.listen_for event_name, handler2
+    expect { subject.send trigger }.to trigger(handler2).but_not(handler)
+  end
+
+  it "works after clearing all listeners" do
+    subject.listen_for event_name, handler
+    subject.clear_all
+    subject.listen_for event_name, handler2
+    expect { subject.send trigger }.to trigger(handler2).but_not(handler)
+  end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: dilation
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Jim Deville
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !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 controllable timer
+email:
+- james.deville@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .yardopts
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- dilation.gemspec
+- lib/dilation.rb
+- lib/dilation/core.rb
+- lib/dilation/test_support/handler.rb
+- lib/dilation/timers/coarse.rb
+- lib/dilation/timers/test.rb
+- lib/dilation/timers/timer.rb
+- lib/dilation/utils/dilator.rb
+- lib/dilation/utils/events.rb
+- lib/dilation/version.rb
+- spec/dilation/core_spec.rb
+- spec/dilation/utils/dilator_spec.rb
+- spec/integration.rb
+- spec/spec_mini.rb
+- spec/support/matchers.rb
+- spec/support/shared_examples.rb
+homepage: http://github.com/jredville/dilation
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.5
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A timer that provides an event based interface to hook into for your app.
+  In addition, the back end timer can be swapped out, so for testing, you can control
+  the passage of time.
+test_files:
+- spec/dilation/core_spec.rb
+- spec/dilation/utils/dilator_spec.rb
+- spec/integration.rb
+- spec/spec_mini.rb
+- spec/support/matchers.rb
+- spec/support/shared_examples.rb
+has_rdoc: