midi-topaz 0.0.15 → 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9451f1766a035db3721179e7deb859f9a1bf9e88
+  data.tar.gz: a4d0c37c97e698f64876210c24ab4039809f5cb1
+SHA512:
+  metadata.gz: 21c97b8c699007e2e26b3e00db19977b8d465d7765b509487bad9524bbee4aaec30f88d01d688459a4ef0c2653627542ae2e278ed5ba6f8ac1e5b729f7a14956
+  data.tar.gz: 1163165b5d6e5b8308e71cdb6aea313c178c02b90cc9f622b21b47c26f52a2684fb3485f67ae981cdb40155f3733e15ed6be716510ba2160386af1291d94a974

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2011 Ari Russo
+Copyright 2011-2014 Ari Russo
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -10,4 +10,4 @@ Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
-limitations under the License.
+limitations under the License.

data/{README.rdoc → README.md}

@@ -1,96 +1,119 @@
-= topaz
+# Topaz
 
-{pic}[http://images.treetrouble.net/images/topaz.jpg]
+![pic](http://img526.imageshack.us/img526/5781/topazt.jpg)
 
 MIDI syncable tempo in Ruby
 
-== Installation
+## Installation
 
-  gem install midi-topaz
+`gem install midi-topaz`
   
-== Requirements
-
-* {gamelan}[http://github.com/jvoorhis/gamelan]
-* {midi-eye}[http://github.com/arirusso/midi-eye]
-* {midi-message}[http://github.com/arirusso/midi-message]
-* {unimidi}[http://github.com/arirusso/unimidi]
+  or with Bundler, add this to your Gemfile
+  
+`gem "midi-topaz"` 
 
-these will install automatically with the gem
+## Usage
 
-== Usage
+```ruby
+require "topaz"
+```
 
-  require "topaz"
-  
 For demonstration purposes, here's a mock sequencer class and object
 
-  class Sequencer
+```ruby
+class Sequencer
     
-    def step
-      @i ||= 0
-      $stdout.puts "step #{@i+=1}"
-    end
-      
+  def step
+    @i ||= 0
+    puts "step #{@i+=1}"
   end
+      
+end
   
-  seq = Sequencer.new
+sequencer = Sequencer.new
+```
 
 The simplest application of Topaz is to create a clock to step that sequencer at a given rate.  Using timing generated internally by your computer, the passed in block will be called repeatedly at 130 BPM
 
-  @tempo = Topaz::Tempo.new(130) { seq.step }
+```ruby
+@tempo = Topaz::Tempo.new(130) { sequencer.step }
+```
 
 You may also use another MIDI device to generate timing and control the tempo.  The unimidi input to which that device is connected can be passed to the Tempo constructor    
 
-  @input = UniMIDI::Input.first.open # an midi input 
+```ruby
+@input = UniMIDI::Input.first.open # an midi input 
   
-  @tempo = Topaz::Tempo.new(@input) { seq.step }
+@tempo = Topaz::Tempo.new(@input) { sequencer.step }
+```
         
 Topaz can also act as a master clock. If a MIDI output is passed to Topaz, MIDI start, stop and clock signals will automatically be sent to that output at the appropriate time
 
-  @output = UniMIDI::Output.first.open # a midi output 
-  
-  @tempo = Topaz::Tempo.new(120, :midi => @output) { seq.step }
+```ruby
+@output = UniMIDI::Output.first.open # a midi output 
   
+@tempo = Topaz::Tempo.new(120, :midi => @output) do
+  sequencer.step
+end
+```
+
 Input and multiple outputs can be used simultaneously
 
-  @tempo = Topaz::Tempo.new(@input, :midi => [@output1, @output2]) { seq.step }
-  
+```ruby
+@tempo = Topaz::Tempo.new(@input, :midi => [@output1, @output2]) do 
+  sequencer.step
+end
+```
+
 Once the Tempo object is initialized, start the clock
 
-  @tempo.start
-  
+```ruby
+@tempo.start
+```
+
 If you are syncing to external clock, nothing will happen until a "start" or "clock" message is received
   
-==== Other things to note
+#### Other things to note
 
 Whether or not you are using an internal or external clock source, the event block will be called at quarter note intervals by default.  If you wish to change this set the option :interval.  In this case, the event will be fired 4 times per beat (16th notes) at 138 BPM   
 
-  @tempo = Topaz::Tempo.new(138, :interval => 16) { seq.step }
+```ruby
+@tempo = Topaz::Tempo.new(138, :interval => 16) do
+  sequencer.step
+end
+```
   
 View the current tempo, which is calculated by Topaz if you're using an external MIDI source.
 (this feature is currently in-progress and may return some low values - 5/26/2011)
 
-  @tempo.tempo
-    => 132.422000
-      
+```ruby
+@tempo.tempo
+  => 132.422000
+```
+
 Run the generator in a background thread by passing :background => true to Tempo#start
 
-  @tempo.start(:background => true)
+```ruby
+@tempo.start(:background => true)
+```
   
 Pass in a block that will stop the clock when it evaluates to true
 
-  @tempo.stop_when { @i.eql?(20) }
+```ruby
+@tempo.stop_when { @i.eql?(20) }
+```
     
-== Documentation
+## Documentation
 
-* {examples}[http://github.com/arirusso/topaz/tree/master/examples]
-* {rdoc}[http://rdoc.info/gems/midi-topaz] 
+* [examples](http://github.com/arirusso/topaz/tree/master/examples)
+* [rdoc](http://rdoc.info/gems/midi-topaz)
 
-== Author
+## Author
 
-* {Ari Russo}[http://github.com/arirusso] <ari.russo at gmail.com>
+* [Ari Russo](http://github.com/arirusso) <ari.russo at gmail.com>
 
-== License
+## License
 
 Apache 2.0, See the file LICENSE
 
-Copyright (c) 2011 Ari Russo
+Copyright (c) 2011-2014 Ari Russo

data/lib/topaz/events.rb

@@ -0,0 +1,44 @@
+module Topaz
+  
+  # User defined callbacks for tempo events
+  class Events
+
+    attr_reader :tick
+    attr_accessor :midi_clock, :midi_start, :midi_stop, :start, :stop, :stop_when
+
+    def initialize()
+      @start = []
+      @stop = []
+      @tick = [] 
+
+      @midi_clock = nil
+      @midi_start = nil
+      @midi_stop = nil
+      @stop_when = nil
+    end
+    
+    def do_midi_clock
+      @midi_clock.call
+    end
+
+    def do_start
+      @midi_start.call
+      @start.each(&:call)
+    end
+
+    def do_stop
+      @midi_stop.call
+      @stop.each(&:call)
+    end
+    
+    def do_tick
+      @tick.each(&:call)
+    end
+    
+    def stop?
+      @stop_when.call unless @stop_when.nil?
+    end
+   
+  end
+  
+end

data/lib/topaz/external_midi_tempo.rb

@@ -1,23 +1,20 @@
-#!/usr/bin/env ruby
 module Topaz
   
-  # trigger an event based on received midi clock messages
+  # Trigger an event based on received midi clock messages
   class ExternalMIDITempo
-    
-    include TempoSource
-   
+      
     attr_reader :clock
   
-    def initialize(actions, input, options = {})
-      @actions = actions
-      self.interval = options[:interval] || 4
+    def initialize(events, input, options = {})
+      @events = events
       @tempo_calculator = TempoCalculator.new
       @clock = MIDIEye::Listener.new(input)
-      
+      self.interval = options[:interval] || 4
+
       initialize_clock 
     end
     
-    # this will return a calculated tempo
+    # This will return a calculated tempo
     def tempo
       @tempo_calculator.find_tempo
     end
@@ -56,7 +53,7 @@ module Topaz
       @per_tick = 24 / per_qn
     end
     
-    # return the interval at which the tick event is fired
+    # Return the interval at which the tick event is fired
     def interval
       4 * (24 / @per_tick)
     end
@@ -65,12 +62,13 @@ module Topaz
     
     def initialize_clock
       @counter = 0
+      # Note that this doesn't wait for a start signal
       @clock.listen_for(:name => "Clock") do |msg|        
-        (stop and return) if stop?
-        do_midi_clock
+        (stop and return) if @events.stop?
+        @events.do_midi_clock # thru
         @tempo_calculator.timestamps << msg[:timestamp]
         if @counter.eql?(@per_tick)
-          do_tick
+          @events.do_tick
           @counter = 0 
         else
           @counter += 1
@@ -80,4 +78,4 @@ module Topaz
     
   end
   
-end
+end

data/lib/topaz/internal_tempo.rb

@@ -1,17 +1,13 @@
-#!/usr/bin/env ruby
 module Topaz
 
   class InternalTempo < Gamelan::Timer
-    
-    include TempoSource
-    
-    attr_accessor :action
-    
-    def initialize(actions, tempo, options = {})
-      @actions = actions
-      self.interval = options[:interval] || 4 
+            
+    def initialize(events, tempo, options = {})
+      @events = events
       @last = 0
       @last_sync = 0
+      self.interval = options[:interval] || 4 
+      
       super({:tempo => tempo})
     end
 
@@ -19,7 +15,7 @@ module Topaz
     # pass :background => true to keep the timer in a background thread
     def start(options = {})
       run
-      join unless options[:background]
+      join unless !!options[:background]
       self
     end
     
@@ -50,13 +46,13 @@ module Topaz
       # stuff to do on every tick      
       if time_for_midi_clock?
         # look for stop
-        (stop and return) if stop?
-        do_midi_clock        
+        (stop and return) if @events.stop?
+        @events.do_midi_clock        
         @last_sync = (@phase * 24).to_i
       end
       # stuff to do on @interval
       if time_for_tick?
-        do_tick
+        @events.do_tick
         @last = (@phase * @interval).to_i
       end      
     end

data/lib/topaz/midi_sync_output.rb

@@ -1,30 +1,32 @@
-#!/usr/bin/env ruby
 module Topaz
   
-  # send sync messages via MIDI
+  # Send clock messages via MIDI
   class MIDISyncOutput
     
     attr_reader :output
      
-    def initialize(output, options = {})
+    def initialize(output)
       @output = output
     end
     
-    # send a start message
+    # Send a start message
     def start(*a)
-      @output.puts(MIDIMessage::SystemRealtime["Start"].new.to_a)
+      start = MIDIMessage::SystemRealtime["Start"].new.to_a
+      @output.puts(start)
     end
 
-    # send a stop message
+    # Send a stop message
     def stop(*a)
-      @output.puts(MIDIMessage::SystemRealtime["Stop"].new.to_a)
+      stop = MIDIMessage::SystemRealtime["Stop"].new.to_a
+      @output.puts(stop)
     end
         
-    # send a clock message
-    def midi_clock(*a)
-      @output.puts(MIDIMessage::SystemRealtime["Clock"].new.to_a)
+    # Send a clock tick message
+    def clock(*a)
+      clock = MIDIMessage::SystemRealtime["Clock"].new.to_a
+      @output.puts(clock)
     end
     
   end
   
-end
+end

data/lib/topaz/tempo.rb

@@ -1,7 +1,6 @@
-#!/usr/bin/env ruby
 module Topaz
   
-  # main tempo class
+  # Main tempo class
   class Tempo
     
     extend Forwardable
@@ -10,96 +9,73 @@ module Topaz
     
     def_delegators :source, :tempo, :interval, :interval=, :join
   
-    def initialize(tempo_or_input, options = {}, &event)
+    def initialize(tempo_or_input, options = {}, &tick_event)
       @paused = false
-      @destinations = []      
-      @actions = { 
-        :start => nil,
-        :stop => nil,
-        :tick => nil,        
-        :midi_clock => Proc.new { @destinations.each { |d| d.send(:midi_clock) if d.respond_to?(:midi_clock) } },
-        :stop_when => nil
-      }
-      
-      on_tick(&event)
+      @destinations = [] 
+      @events = Events.new
 
-      if tempo_or_input.kind_of?(Numeric)
-        @source = InternalTempo.new(@actions, tempo_or_input)
-      else      
-        midi_clock_source = tempo_or_input
-      end
-       
-      initialize_midi_io(options[:midi], midi_clock_source)
-      raise "You must specify an internal tempo rate or an external tempo source" if @source.nil?
-              
-      @source.interval = options[:interval] unless options[:interval].nil?      
-      
+      configure(tempo_or_input, options, &tick_event)     
     end
     
-    # this will change the tempo
+    # Change the tempo
     #
-    # be warned, in the case that external midi tempo is being used, this will switch to internal 
-    # tempo at the desired rate
+    # Caution that in the case that external MIDI tempo is being used, this will switch to internal 
+    # tempo at the desired rate.
     #
     def tempo=(val)
       if @source.respond_to?(:tempo=)
         @source.tempo = val
       else
-        @source = InternalTempo.new(tempo, @action)
+        @source = InternalTempo.new(@events, val)
       end 
     end
     
-    # pause the clock
+    # Pause the clock
     def pause
       @pause = true
     end
     
-    # unpause the clock
+    # Unpause the clock
     def unpause
       @pause = false
     end
     
-    # is this clock paused?
+    # Is this clock paused?
     def paused?
       @pause
     end
    
+    # Toggle pausing the clock
     def toggle_pause
       paused? ? unpause : pause      
     end
     
-    # pass in a callback that is called when start is called
-    def on_start(&block)
-      @actions[:start] = block
+    # Pass in a callback that is called when start is called
+    def on_start(&callback)
+      @events.start[0] = callback
     end
 
     # pass in a callback that is called when stop is called
-    def on_stop(&block)
-      @actions[:stop] = block
-    end
-    
-    # pass in a callback which will stop the clock if it evaluates to true 
-    def stop_when(&block)
-      proc = Proc.new do
-        if yield
-          stop
-          true
-        else
-          false
-        end 
-      end
-      @actions[:stop_when] = proc
+    def on_stop(&callback)
+      @events.stop[0] = callback
+    end
+    
+    # Pass in a callback which will stop the clock if it evaluates to true 
+    def stop_when(&callback)
+      @events.stop_when = callback
     end
     
-    # pass in a callback which will be fired on each tick
-    def on_tick(&block)
-      proc = Proc.new do
+    # Pass in a callback which will be fired on each tick
+    def on_tick(&callback)
+      wrapper = Proc.new do
         unless paused?
-          @destinations.each { |d| d.send(:tick) if d.respond_to?(:tick) }
+          @destinations.each do |destination| 
+            destination.send(:tick) if destination.respond_to?(:tick)
+          end
           yield
         end
       end
-      @actions[:tick] = proc
+      @events.tick[0] = callback
     end
         
     # this will start the generator
@@ -109,39 +85,38 @@ module Topaz
     #
     def start(options = {})
       @start_time = Time.now
-      @destinations.each { |dest| dest.start }
+      @events.do_start
       @source.start(options)
-      @actions[:start].call unless @actions[:start].nil?
     end
     
-    # this will stop tempo
+    # This will stop the clock
     def stop(options = {})
-      @destinations.each { |dest| dest.stop }
       @source.stop(options)
-      @actions[:stop].call unless @actions[:stop].nil?
+      @events.do_stop
       @start_time = nil
     end
     
-    # seconds since start was called
+    # Seconds since start was called
     def time
-      @start_time.nil? ? nil : (Time.now - @start_time).to_f
+      (Time.now - @start_time).to_f unless @start_time.nil?
     end
     alias_method :time_since_start, :time
     
-    # add a destination
-    # accepts UniMIDI::Output or array of
-    def add_destination(dest)
-      dest = [dest].flatten.compact
-      dest.each do |d|
-        @destinations << MIDISyncOutput.new(d)
+    # Add a destination
+    # @param [Array<UniMIDI::Output>, UniMIDI::Output] destinations
+    def add_destination(destinations)
+      destinations = [destinations].flatten.compact
+      destinations.each do |destination|
+        output = MIDISyncOutput.new(destination) 
+        @destinations << output
       end
     end
 
-    # remove a destination
-    # accepts UniMIDI::Output or array of
-    def remove_destination(dest)
-      dest = [dest].flatten.compact
-      dest.each do |output|
+    # Remove a destination
+    # @param [Array<UniMIDI::Output>, UniMIDI::Output] destinations
+    def remove_destination(destinations)
+      destinations = [destinations].flatten.compact
+      destinations.each do |output|
         @destinations.each do |sync_output|
           @destinations.delete(sync_output) if sync_output.output == output
         end
@@ -151,22 +126,44 @@ module Topaz
     protected
     
     def tick
-      @actions[:tick].call
+      @events.do_tick
     end
     
     private
         
-    def initialize_midi_io(midi_ports, midi_clock = nil)
-      @source = ExternalMIDITempo.new(@actions, midi_clock) unless midi_clock.nil? || !@source.nil?
-      unless midi_ports.nil?
-        if midi_ports.kind_of?(Array) 
-          midi_ports.each { |port| initialize_midi_io(port) }
-        elsif midi_ports.type.eql?(:output)
-          @destinations << MIDISyncOutput.new(midi_ports)
+    def initialize_destinations(midi_outputs)
+      midi_outputs = [midi_outputs].flatten.compact
+      midi_outputs.each do |output|
+        add_destination(output)
+      end
+    end
+
+    def initialize_midi_clock_output
+      [:clock, :start, :stop].each do |event|
+        action = Proc.new do
+          @destinations.each { |destination| destination.send(event) }
         end
+        @events.send("midi_#{event.to_s}=", action)
       end
-    end    
+    end
+
+    def initialize_tempo_source(tempo_or_input)
+      @source = case tempo_or_input
+        when Numeric then InternalTempo.new(@events, tempo_or_input)
+        when UniMIDI::Input then ExternalMIDITempo.new(@events, tempo_or_input)
+      else
+        raise "You must specify an internal tempo rate or an external tempo source"
+      end
+    end
+
+    def configure(tempo_or_input, options = {}, &tick_event)
+      initialize_tempo_source(tempo_or_input)     
+      initialize_destinations(options[:midi]) unless options[:midi].nil?
+      initialize_midi_clock_output
+      @source.interval = options[:interval] unless options[:interval].nil? 
+      on_tick(&tick_event)
+    end
     
   end
   
-end
+end

data/lib/topaz/tempo_calculator.rb

@@ -1,21 +1,22 @@
-#!/usr/bin/env ruby
 module Topaz
   
+  # Calculate tempo given timestamps
   class TempoCalculator
+
+    THRESHOLD = 6 # minimum number of ticks to analyze
     
     attr_reader :tempo, :timestamps
     
-    def initialize(tempo = nil)
-      @tempo = tempo
+    def initialize
+      @tempo = nil
       @timestamps = []
-      @counter = 0
     end
     
-    # analyse the tempo based on the last 6 ticks
+    # Analyze the tempo based on the threshold
     def find_tempo
       tempo = nil
       diffs = []
-      @timestamps.shift while @timestamps.length > 6
+      @timestamps.shift while @timestamps.length > THRESHOLD
       @timestamps.each_with_index { |n, i| (diffs << (@timestamps[i+1] - n)) unless @timestamps[i+1].nil? }
       unless diffs.empty?
         avg = (diffs.inject { |a, b| a + b }.to_f / diffs.length.to_f) 
@@ -35,4 +36,4 @@ module Topaz
     
   end
   
-end
+end

data/lib/topaz.rb

@@ -1,23 +1,24 @@
-#!/usr/bin/env ruby
 #
 # MIDI syncable tempo module in Ruby
-# (c)2011 Ari Russo and licensed under the Apache 2.0 License
+# (c)2011-2014 Ari Russo and licensed under the Apache 2.0 License
 # 
 
-require 'forwardable'
-require 'gamelan'
-require 'midi-eye'
-require 'midi-message'
+# libs
+require "forwardable"
+require "gamelan"
+require "midi-eye"
+require "midi-message"
 
-require 'topaz/tempo_source'
-require 'topaz/external_midi_tempo'
-require 'topaz/internal_tempo'
-require 'topaz/midi_sync_output'
-require 'topaz/tempo_calculator'
-require 'topaz/tempo'
+# classes
+require "topaz/events"
+require "topaz/external_midi_tempo"
+require "topaz/internal_tempo"
+require "topaz/midi_sync_output"
+require "topaz/tempo_calculator"
+require "topaz/tempo"
 
 module Topaz
   
-  VERSION = "0.0.15"
+  VERSION = "0.1.1"
   
-end
+end

data/test/config.rb

@@ -1,13 +1,11 @@
-#!/usr/bin/env ruby
-
 module TestHelper::Config
 
   include UniMIDI
 
-  # adjust these constants to suit your hardware configuration
+  # Adjust these constants to suit your hardware configuration
   # before running tests
 
-  TestInput = Input.first # this is the device you wish to use to test input
-  TestOutput = Output.first # likewise for output
+  TestInput = Input.gets # this is the device you wish to use to test input
+  TestOutput = Output.gets # likewise for output
 
-end
+end

data/test/helper.rb

@@ -1,14 +1,10 @@
-#!/usr/bin/env ruby
-
 dir = File.dirname(File.expand_path(__FILE__))
-$LOAD_PATH.unshift dir + '/../lib'
+$LOAD_PATH.unshift dir + "/../lib"
 
-require 'test/unit'
-require 'topaz'
+require "test/unit"
+require "topaz"
 
-module TestHelper
-	
-  
+module TestHelper 
 end
 
-require File.dirname(__FILE__) + '/config'
+require File.dirname(__FILE__) + "/config"

data/test/{test_internal_tempo.rb → internal_tempo_test.rb}

@@ -1,6 +1,4 @@
-#!/usr/bin/env ruby
-
-require 'helper'
+require "helper"
 
 class InternalTempoTest < Test::Unit::TestCase
 
@@ -50,4 +48,4 @@ class InternalTempoTest < Test::Unit::TestCase
     assert_equal(8, tempo.interval)
   end
 
-end
+end

metadata

@@ -1,111 +1,130 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: midi-topaz
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.0.15
+version: !ruby/object:Gem::Version
+  version: 0.1.1
 platform: ruby
-authors: 
+authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-30 00:00:00 -04:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2014-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: gamelan
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: midi-message
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: 0.0.4
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: midi-message
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
     - - ">="
-      - !ruby/object:Gem::Version 
+      - !ruby/object:Gem::Version
         version: 0.0.4
-  type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+- !ruby/object:Gem::Dependency
   name: midi-eye
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
     - - ">="
-      - !ruby/object:Gem::Version 
+      - !ruby/object:Gem::Version
         version: 0.0.7
   type: :runtime
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: unimidi
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: unimidi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
     - - ">="
-      - !ruby/object:Gem::Version 
+      - !ruby/object:Gem::Version
         version: 0.1.10
   type: :runtime
-  version_requirements: *id004
-description: MIDI syncable tempo in Ruby
-email: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.10
+description: A flexible tempo source that is capable of synchronizing with MIDI clocks.
+email:
 - ari.russo@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- LICENSE
+- README.md
 - lib/topaz.rb
-- lib/topaz/midi_sync_output.rb
-- lib/topaz/internal_tempo.rb
-- lib/topaz/tempo_calculator.rb
-- lib/topaz/tempo_source.rb
+- lib/topaz/events.rb
 - lib/topaz/external_midi_tempo.rb
+- lib/topaz/internal_tempo.rb
+- lib/topaz/midi_sync_output.rb
 - lib/topaz/tempo.rb
-- test/helper.rb
+- lib/topaz/tempo_calculator.rb
 - test/config.rb
-- test/test_internal_tempo.rb
-- LICENSE
-- README.rdoc
-has_rdoc: true
+- test/helper.rb
+- test/internal_tempo_test.rb
 homepage: http://github.com/arirusso/topaz
-licenses: []
-
+licenses:
+- Apache-2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
+    - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-
 rubyforge_project: midi-topaz
-rubygems_version: 1.6.2
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: MIDI syncable tempo in Ruby
 test_files: []
-

data/lib/topaz/tempo_source.rb

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-module Topaz
-  
-  module TempoSource
-    
-    def do_midi_clock
-      @actions[:midi_clock].call
-    end
-    
-    def do_tick
-      @actions[:tick].call
-    end
-    
-    def stop?
-      !@actions[:stop_when].nil? && @actions[:stop_when].call
-    end
-   
-  end
-  
-end