midi-topaz 0.1.2 → 0.2.1

data/lib/topaz/timer.rb

@@ -0,0 +1,132 @@
+module Topaz
+
+  class Timer < Gamelan::Timer
+
+    include Pausable
+
+    attr_reader :phase, :running
+    alias_method :running?, :running
+
+    # @param [Fixnum] tempo
+    # @param [Hash] options
+    # @option options [Clock::Event] :event
+    def initialize(tempo, options = {})
+      @event = options[:event]
+      @last_tick_event = 0
+      @last_midi_clock = 0
+      @pause = false
+      @running = false
+      self.interval = options[:interval] || 4 
+      
+      super({ :tempo => tempo })
+    end
+
+    # Start the internal timer
+    # @param [Hash] options
+    # @option options [Boolean] :background Whether to run the timer in a background thread (default: false)
+    # @return [Timer]
+    def start(options = {})
+      run
+      !@event.nil? && @event.do_start
+      join unless !!options[:background]
+      self
+    end
+    
+    # Set the timer's click interval
+    # @param [Fixnum] value
+    # @return [Fixnum]
+    def interval=(value)
+      @interval = value / 4
+    end
+    
+    # The timer's click interval
+    # @return [Fixnum]
+    def interval
+      @interval * 4
+    end
+    
+    # Stop the timer
+    # @return [Timer]
+    def stop(*a)
+      super()
+      !@event.nil? && @event.do_stop
+      self
+    end
+    
+    # Join the timer thread
+    # @return [Timer]
+    def join
+      super()
+      self
+    end
+    
+    protected
+
+    # Initialize the scheduler's clock, and begin executing tasks
+    # @return [Boolean]
+    def run
+      unless @running
+        @thread = Thread.new do
+          begin
+            initialize_running_state
+            loop do 
+              dispatch 
+              advance
+            end
+          rescue Exception => exception
+            Thread.main.raise(exception)
+          end
+        end
+        @thread.abort_on_exception = true
+        true
+      else
+        false
+      end
+    end 
+
+    # Run all ready tasks.
+    # @return [Boolean]
+    def dispatch
+      # Stuff to do on every tick      
+      if time_for_midi_clock?
+        # look for stop
+        !@event.nil? && @event.do_clock        
+        @last_midi_clock = (@phase * 24).to_i
+        true
+      end
+      # Stuff to do on @interval
+      if time_for_tick?
+        !@event.nil? && !@pause && @event.do_tick
+        @last_tick_event = (@phase * @interval).to_i
+        true
+      end
+    end
+    
+    private
+
+    # Initialize the variables that handle the running process of the timer
+    # @return [Boolean]
+    def initialize_running_state
+      @running = true
+      @phase = 0.0
+      @origin = @time = Time.now.to_f
+      true
+    end
+    
+    # Is the current phase appropriate for MIDI clock output?
+    # @return [Boolean]
+    def time_for_midi_clock?
+      phase = (@phase * 24).to_i
+      !@last_midi_clock.eql?(phase)
+    end
+    
+    # Is the current phase appropriate for the tick event?
+    # @return [Boolean]
+    def time_for_tick?
+      phase = (@phase * @interval).to_i
+      !@last_tick_event.eql?(phase)
+    end
+     
+  end
+  
+end

data/lib/topaz.rb

@@ -9,16 +9,20 @@ require "gamelan"
 require "midi-eye"
 require "midi-message"
 
+# modules
+require "topaz/api"
+require "topaz/pausable"
+require "topaz/tempo_source"
+
 # classes
-require "topaz/events"
-require "topaz/external_midi_tempo"
-require "topaz/internal_tempo"
-require "topaz/midi_sync_output"
+require "topaz/clock"
+require "topaz/midi_clock_input"
+require "topaz/midi_clock_output"
 require "topaz/tempo_calculator"
-require "topaz/tempo"
+require "topaz/timer"
 
 module Topaz
   
-  VERSION = "0.1.2"
+  VERSION = "0.2.1"
   
 end

data/test/clock_test.rb

@@ -0,0 +1,63 @@
+require "helper"
+
+class Topaz::ClockTest < Test::Unit::TestCase
+
+  context "Clock" do
+
+    setup do
+      @counter = 0
+      @count_to = 5
+      @tempo = Topaz::Clock.new(120) { @counter += 1 }
+    end
+
+    context "#interval=" do
+
+      should "change interval" do
+        assert_equal(4, @tempo.interval)
+        @tempo.interval = 8
+        assert_equal(8, @tempo.interval)
+      end
+
+    end
+
+    context "Event" do
+
+      context "#tick" do
+
+        should "change tick" do
+          @is_running = false
+          @tempo.event.tick { @is_running = true }
+          refute @is_running
+
+          @tempo.start(:background => true)
+          loop until @tempo.running?
+          loop until @is_running
+
+        end
+
+      end
+
+    end
+
+    context "Trigger" do
+
+      context "#stop" do
+
+        setup do
+          @tempo.trigger.stop { @counter.eql?(@count_to) }
+        end
+
+        should "stop" do
+          @tempo.start
+          assert_equal(@count_to, @counter)
+        end
+
+      end
+
+    end
+
+
+
+  end
+end
+

data/test/helper.rb

@@ -2,9 +2,19 @@ dir = File.dirname(File.expand_path(__FILE__))
 $LOAD_PATH.unshift dir + "/../lib"
 
 require "test/unit"
+require "mocha/test_unit"
+require "shoulda-context"
 require "topaz"
 
-module TestHelper 
+module TestHelper
+  
+  def self.select_devices
+    $test_device ||= {}
+    { :input => UniMIDI::Input, :output => UniMIDI::Output }.each do |type, klass|
+      $test_device[type] = klass.gets
+    end
+  end
+     
 end
 
-require File.dirname(__FILE__) + "/config"
+TestHelper.select_devices

data/test/midi_clock_input_test.rb

@@ -0,0 +1,51 @@
+require "helper"
+
+class Topaz::MIDIClockInputTest < Test::Unit::TestCase
+
+  context "MIDIClockInput" do
+
+    setup do
+      @input = Object.new
+      @event = Object.new
+      @clock = Topaz::MIDIClockInput.new(@input, :event => @event)
+    end
+
+    context "#thru" do
+
+      should "fire clock event" do
+        @event.expects(:do_clock).once
+        assert @clock.send(:thru)
+      end
+
+    end
+
+    context "#tick" do
+
+      should "fire tick event" do
+        @event.expects(:do_tick).once
+        assert @clock.send(:tick)
+      end
+
+    end
+
+    context "#tick?" do
+
+      should "tick when counter has reached tick threshold" do
+        assert_equal 4, @clock.interval
+        23.times do 
+          refute @clock.send(:tick?)
+          @clock.send(:advance)
+        end
+        assert @clock.send(:tick?)
+        @clock.send(:advance)
+      end
+
+    end
+
+  end
+
+end
+
+
+
+

data/test/midi_clock_output_test.rb

@@ -0,0 +1,50 @@
+require "helper"
+
+class Topaz::MIDIClockOutputTest < Test::Unit::TestCase
+
+  context "MIDIClockOutput" do
+
+    setup do
+      @output = Object.new
+      @clock = Topaz::MIDIClockOutput.new(:device => @output)
+    end
+
+    context "#do_start" do
+      
+      should "emit start message" do
+        @output.expects(:puts).once.with(250)
+        result = @clock.do_start
+        assert result
+        @output.unstub(:puts)
+      end
+
+    end
+
+    context "#do_stop" do
+
+      should "emit stop message" do
+        @output.expects(:puts).once.with(252)
+        result = @clock.do_stop
+        assert result
+        @output.unstub(:puts)
+      end
+
+    end
+
+    context "#do_clock" do
+
+      should "emit clock message" do
+        @output.expects(:puts).once.with(248)
+        result = @clock.do_clock
+        assert result
+        @output.unstub(:puts)
+      end
+
+    end
+
+  end
+
+end
+
+
+

data/test/tempo_calculator_test.rb

@@ -0,0 +1,39 @@
+require "helper"
+
+class Topaz::TempoCalculatorTest < Test::Unit::TestCase
+
+  context "TempoCalculator" do
+
+    setup do
+      @calc = Topaz::TempoCalculator.new
+    end
+
+    context "#calculate" do
+
+      should "wait for two timestamps to start calculation" do
+        @calc.timestamps << 1
+        assert_nil @calc.calculate
+        @calc.timestamps << 2
+        @calc.timestamps << 3
+        assert_not_nil @calc.calculate
+      end
+
+      should "limit timestamps do within the threshold" do
+        10.times { |i| @calc.timestamps << i }
+        @calc.calculate
+        assert_equal Topaz::TempoCalculator::THRESHOLD, @calc.timestamps.count
+      end
+
+      should "express tempo" do
+        5.times { |i| @calc.timestamps << Time.now.to_f; sleep(1.0 / 24.0) }
+        result = @calc.calculate
+        assert_not_nil result
+        assert (58..62).include?(result)
+      end
+
+    end
+
+  end
+
+end
+

data/test/tempo_source_test.rb

@@ -0,0 +1,33 @@
+require "helper"
+
+class Topaz::TempoSourceTest < Test::Unit::TestCase
+
+  context "TempoSource" do
+
+    context ".new" do
+
+      should "construct a timer" do
+        result = Topaz::TempoSource.new(120)
+        assert_not_nil result
+        assert_equal Topaz::Timer, result.class
+      end
+
+      should "construct a midi input clock" do
+        result = Topaz::TempoSource.new($test_device[:input])
+        assert_not_nil result
+        assert_equal Topaz::MIDIClockInput, result.class
+      end
+
+      should "throw an exception" do
+        assert_raise RuntimeError do
+          Topaz::TempoSource.new("something")
+        end
+      end
+
+    end
+
+  end
+
+end
+
+

data/test/timer_test.rb

@@ -0,0 +1,76 @@
+require "helper"
+
+class Topaz::TimerTest < Test::Unit::TestCase
+
+  context "Timer" do
+
+    setup do
+      @timer = Topaz::Timer.new(120)
+    end
+
+    context "#dispatch" do
+
+      setup do
+        @event = Object.new
+        @timer = Topaz::Timer.new(120, :event => @event)
+        @timer.send(:initialize_running_state)
+      end
+
+      should "fire MIDI clock event" do
+        @event.expects(:do_clock).once.returns(true)
+        @timer.send(:dispatch)
+      end
+
+      should "fire tick event" do
+        @event.expects(:do_tick).once.returns(true)
+        @timer.send(:dispatch)
+      end
+
+    end
+
+    context "#start" do
+
+      should "start running" do
+        assert_nil @timer.phase
+        @timer.start(:background => true)
+        loop until @timer.running?
+
+        assert @timer.running?
+        assert_not_nil @timer.phase
+        assert_not_equal 0.0, @timer.phase
+      end
+
+    end
+
+    context "#stop" do
+
+      setup do
+        assert_nil @timer.phase
+        @timer.start(:background => true)
+        loop until @timer.running?
+
+        assert @timer.running?
+      end
+
+      should "stop running" do
+        assert_not_nil @timer.phase
+        assert_not_equal 0.0, @timer.phase
+        @timer.stop
+        refute @timer.running?
+      end
+
+    end
+    
+    context "#interval=" do
+
+      should "change interval" do
+        assert_equal(4, @timer.interval)
+        @timer.interval = 8
+        assert_equal(8, @timer.interval)
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: midi-topaz
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-19 00:00:00.000000000 Z
+date: 2014-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gamelan
@@ -94,15 +94,21 @@ files:
 - LICENSE
 - README.md
 - lib/topaz.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
+- lib/topaz/api.rb
+- lib/topaz/clock.rb
+- lib/topaz/midi_clock_input.rb
+- lib/topaz/midi_clock_output.rb
+- lib/topaz/pausable.rb
 - lib/topaz/tempo_calculator.rb
-- test/config.rb
+- lib/topaz/tempo_source.rb
+- lib/topaz/timer.rb
+- test/clock_test.rb
 - test/helper.rb
-- test/internal_tempo_test.rb
+- test/midi_clock_input_test.rb
+- test/midi_clock_output_test.rb
+- test/tempo_calculator_test.rb
+- test/tempo_source_test.rb
+- test/timer_test.rb
 homepage: http://github.com/arirusso/topaz
 licenses:
 - Apache-2.0

data/lib/topaz/events.rb

@@ -1,44 +0,0 @@
-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,81 +0,0 @@
-module Topaz
-  
-  # Trigger an event based on received midi clock messages
-  class ExternalMIDITempo
-      
-    attr_reader :clock
-  
-    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
-    def tempo
-      @tempo_calculator.find_tempo
-    end
-    
-    def start(*a)      
-      @clock.start(*a)
-      self
-    end
-    
-    def stop(*a)
-      @clock.stop
-      self
-    end
-    
-    def join
-      @clock.join
-      self
-    end
-        
-    #
-    # change the clock interval
-    # defaults to click once every 24 ticks or one quarter note which is the MIDI standard.
-    # however, if you wish to fire the on_tick event twice as often 
-    # (or once per 12 clicks), pass 8 
-    #
-    #   1 = whole note
-    #   2 = half note
-    #   4 = quarter note
-    #   6 = dotted quarter
-    #   8 = eighth note
-    #  16 = sixteenth note
-    #  etc
-    #
-    def interval=(val)
-      per_qn = val / 4
-      @per_tick = 24 / per_qn
-    end
-    
-    # Return the interval at which the tick event is fired
-    def interval
-      4 * (24 / @per_tick)
-    end
-    
-    private
-    
-    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 @events.stop?
-        @events.do_midi_clock # thru
-        @tempo_calculator.timestamps << msg[:timestamp]
-        if @counter.eql?(@per_tick)
-          @events.do_tick
-          @counter = 0 
-        else
-          @counter += 1
-        end
-      end
-    end
-    
-  end
-  
-end