basic-sequencer 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 69fcf47b967d669ca28420c35c71dd4a642229da
+  data.tar.gz: 96e296ed53e0f27a539dcfb8f32a9ebf461fc519
+SHA512:
+  metadata.gz: 79b566c5927160eead43d655a1a06c08eea322f63b6ec12bb1bcbf5ed64cfd48ad75aaa9210107829ef39fac244a42f6350278cd9fe3cc96d4084de9bc03d303
+  data.tar.gz: dae58578dc14438b6133954e076679ad6bad8da0606ece4b222cf3488a80b7b934997ca93ffda0693425a8983f0e9286d0267ba5adb47da185e590e8c2286512

data/LICENSE

@@ -0,0 +1,13 @@
+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.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+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.

data/README.md

@@ -0,0 +1,25 @@
+#Sequencer
+
+Perform a sequence of events at tempo
+
+The tempo clock is MIDI syncable by way of [topaz](http://github.com/arirusso/topaz).
+
+This is used by [diamond](http://github.com/arirusso/diamond)
+
+## Installation
+
+`gem install basic-sequencer`
+  
+  or with Bundler, add this to your Gemfile
+  
+`gem "basic-sequencer"` 
+
+## Documentation
+
+* [rdoc](http://rubydoc.info/github/arirusso/sequencer) 
+
+## License
+
+Licensed under Apache 2.0, See the file LICENSE
+
+Copyright © 2011-2014 Ari Russo

data/lib/sequencer.rb

@@ -0,0 +1,24 @@
+#
+# Sequencer
+# Perform a sequence of events at tempo
+#
+# (c)2011-2014 Ari Russo
+# Licensed under Apache 2.0
+# 
+
+# libs
+require "forwardable"
+require "topaz"
+
+# classes
+require "sequencer/clock"
+require "sequencer/core"
+require "sequencer/event"
+require "sequencer/event_trigger"
+require "sequencer/loop"
+
+module Sequencer
+  
+  VERSION = "0.0.4"
+  
+end

data/lib/sequencer/clock.rb

@@ -0,0 +1,75 @@
+module Sequencer 
+
+  # A light wrapper for Topaz::Tempo that adds some event handling
+  class Clock
+
+    extend Forwardable
+
+    attr_reader :event
+    def_delegators :@clock, :pause, :stop, :unpause
+
+    # @param [Fixnum, UniMIDI::Input] tempo_or_input
+    # @param [Hash] options
+    # @option options [Array<UniMIDI::Output>, UniMIDI::Output] :outputs MIDI output device(s)     
+    def initialize(tempo_or_input, options = {})
+      @event = Event.new
+      initialize_clock(tempo_or_input, options.fetch(:resolution, 128), :outputs => options[:outputs])
+    end
+
+    # Start the clock
+    # @param [Hash] options
+    # @option options [Boolean] :blocking Whether to run in the foreground (also :focus, :foreground)
+    # @option options [Boolean] :suppress_clock Whether this clock is a sync-slave
+    # @return [Boolean]
+    def start(options = {})
+      clock_options = {}
+      clock_options[:background] = ![:blocking, :focus, :foreground].any? { |key| !!options[key] }
+      @clock.start(clock_options) unless !!options[:suppress_clock]
+      Thread.abort_on_exception = true
+    end
+
+    private
+
+    # Action taken by the clock on a tick.  Fires the tick event
+    def on_tick
+      @event.do_tick
+    end
+
+    # Instantiate the underlying clock object
+    # @param [Fixnum, UniMIDI::Input] tempo_or_input
+    # @param [Fixnum] resolution
+    # @param [Hash] options
+    # @option options [Array<UniMIDI::Output>, UniMIDI::Output] :outputs MIDI output device(s) 
+    def initialize_clock(tempo_or_input, resolution, options = {})
+      @clock = Topaz::Tempo.new(tempo_or_input, :midi => options[:outputs]) 
+      @clock.interval = @clock.interval * (resolution / @clock.interval)
+      @clock.on_tick { on_tick }
+    end
+
+    # Clock event callbacks
+    class Event
+
+      def initialize
+        @tick = []
+      end
+
+      # Access the tick event callback
+      # @param [Proc] block
+      # @return [Proc]
+      def tick(&block)
+        if block_given?
+          @tick.clear
+          @tick << block
+        end
+        @tick
+      end
+
+      # Fire the tick event callback
+      # @return [Boolean]
+      def do_tick
+        !@tick.empty? && @tick.map(&:call)
+      end
+
+    end
+  end
+end

data/lib/sequencer/core.rb

@@ -0,0 +1,77 @@
+module Sequencer 
+
+  # The core sequencer
+  class Core
+
+    attr_reader :event, :loop, :trigger
+    attr_accessor :pointer
+
+    def initialize
+      @event = Event.new
+      @loop = Loop.new
+      @pointer = 0
+      @trigger = EventTrigger.new
+    end
+
+    # Execute a single cycle of sequencing (perform and step)
+    # @param [Array] sequence The sequence to execute a single cycle of
+    # @return [Boolean] Whether perform and step both finished
+    def exec(sequence)
+      perform(sequence) && step(sequence)
+    end
+
+    # Step the sequencer and fire the step event
+    # @param [Array] sequence
+    # @return [Boolean]
+    def step(sequence)
+      if reset_pointer?(:length => sequence.length)
+        reset_pointer
+      else
+        @pointer += 1
+      end
+      @event.do_step
+      true
+    end
+
+    # If a stop is triggered, stop. Otherwise if reset is triggered, reset. Finally,
+    # fire the perform event on the current step of the sequence
+    # @param [Array] sequence
+    # @return [Boolean] True if perform event was fired
+    def perform(sequence)
+      data = sequence.at(@pointer)
+      @event.do_next(@pointer, data) if @event.next?(@pointer)
+      if @trigger.stop?(@pointer, data)
+        @event.do_stop
+        false
+      else
+        reset_pointer if @trigger.reset?(@pointer, data)
+        @event.do_perform(data)
+        true
+      end
+    end
+
+    # Set the pointer to the loop start point
+    # @return [Fixnum]
+    def reset_pointer
+      @pointer = @loop.next
+    end
+
+    private
+
+    # Is the pointer at the point where it needs to be reset?
+    # @param [Hash] options
+    # @option options [Fixnum] :length The length of the sequence (used when the default loop is active)
+    # @return [Boolean]
+    def reset_pointer?(options = {})
+      !@loop.disabled? && !@loop.in_bounds?(@pointer + 1, :length => options[:length])
+    end
+
+  end
+
+  # Shortcut to the Core constructor
+  # @return [Core]
+  def self.new
+    Core.new
+  end
+
+end

data/lib/sequencer/event.rb

@@ -0,0 +1,86 @@
+module Sequencer 
+
+  # Events that are fired by the sequencer
+  class Event
+
+    def initialize
+      @next = {}
+      @perform = []
+      @step = []
+      @stop = []
+    end
+
+    def next(pointer = nil, &block)
+      if block_given?
+        @next[pointer] ||= []
+        @next[pointer] << block
+      end
+      hash
+    end
+
+    def next?(pointer = nil)
+      !@next[pointer].nil?
+    end
+
+    def do_next(pointer, data)
+      keys = [pointer, nil]
+      callbacks = keys.map { |key| @next.delete(key) }.flatten.compact
+      callbacks.each(&:call)
+      true
+    end
+
+    # Set the step event
+    # @param [Proc] block
+    # @return [Proc]
+    def step(&block)
+      if block_given?
+        @step.clear
+        @step << block
+      end
+      @step
+    end
+
+    # Fire the step events
+    # @return [Boolean]
+    def do_step
+      !@step.empty? && @step.map(:call)
+    end
+
+    # Access the stop events
+    # @param [Proc] block
+    # @return [Proc]
+    def stop(&block)
+      if block_given?
+        @stop.clear
+        @stop << block
+      end
+      @stop
+    end
+
+    # Fire the stop event
+    # @return [Boolean]
+    def do_stop
+      @stop.map(&:call)
+    end
+
+    # Set the perform event
+    # @param [Proc] block
+    # @return [Proc]
+    def perform(&block)
+      if block_given?
+        @perform.clear
+        @perform << block
+      end
+      @perform
+    end
+
+    # Fire the perform event
+    # @param [Object] data Data for the current sequence step 
+    # @return [Boolean]
+    def do_perform(data)
+      @perform.map { |callback| callback.call(data) }
+    end
+                    
+  end
+  
+end

data/lib/sequencer/event_trigger.rb

@@ -0,0 +1,78 @@
+module Sequencer 
+
+  # Callbacks that when evaluate to true, will trigger the corresponding sequencer event
+  class EventTrigger
+          
+    # Set the reset trigger.  When true, the sequence will go back to step 0
+    # @param [Proc] block
+    # @return [Proc]
+    def reset(&block)
+      @reset = block  
+    end
+
+    # Set the rest trigger. When true, no messages will be outputted during that step
+    # @param [Proc] block
+    # @return [Proc]
+    def rest(&block)
+      @rest = block
+    end
+
+    # Whether the reset event should fire
+    # @param [Fixnum] pointer The sequencer pointer
+    # @param [Object] data Data for the current sequence step 
+    # @return [Boolean]
+    def reset?(pointer, data)
+      !@reset.nil? && @reset.call(pointer, data)
+    end
+
+    # Whether the rest event should fire
+    # @param [Fixnum] pointer The sequencer pointer
+    # @param [Object] data Data for the current sequence step 
+    # @return [Boolean]
+    def rest?(pointer, data)
+      !@rest.nil? && @rest.call(pointer, data)
+    end
+
+    # Set the stop trigger. When true, the sequencer will stop
+    # @param [Proc] block
+    # @return [Proc]
+    def stop(&block)
+      @stop = block
+    end
+
+    # Whether to fire the stop event
+    # @param [Fixnum] pointer The sequencer pointer
+    # @param [Object] data Data for the current sequence step 
+    # @return [Boolean]
+    def stop?(pointer, data)
+      !@stop.nil? && @stop.call(pointer, data)
+    end
+        
+    # Shortcut to trigger a rest event on a given interval of ticks
+    # @param [Fixnum, nil] num The number of ticks or nil to cancel existing triggers
+    # @return [Fixnum, nil]
+    def rest_every(num)
+      if num.nil?
+        @rest = nil
+      else
+        rest { |pointer| pointer % num == 0 }
+        num
+      end
+    end
+
+    # Shortcut to trigger a reset even on a given interval of ticks
+    # @param [Fixnum, nil] num The number of ticks or nil to cancel existing triggers
+    # @return [Fixnum, nil]
+    def reset_every(num)
+      if num.nil?
+        @reset = nil
+      else
+        reset { |pointer| pointer % num == 0 }
+        num
+      end
+    end
+            
+  end
+  
+end
+

data/lib/sequencer/loop.rb

@@ -0,0 +1,60 @@
+module Sequencer
+
+  class Loop
+
+    attr_reader :count, :range
+
+    def initialize
+      @count = 0
+      @range = nil
+      @is_disabled = false
+    end
+
+    # Set the loop range
+    # @param [Array<Fixnum>, FalseClass, Fixnum, Range] value
+    # @return [FalseClass, Range]
+    def range=(value)
+      @range = to_range(value)
+    end
+
+    def start
+      default? ? 0 : @range.begin
+    end
+
+    def next
+      @count += 1
+      start
+    end
+
+    def default?
+      @range.nil?
+    end
+
+    def disabled?
+      @is_disabled
+    end
+
+    def disable
+      @is_disabled = true
+    end
+
+    def in_bounds?(num, options = {})
+      length = options[:length]
+      range = default? ? 0..(length-1) : @range
+      range.include?(num)
+    end
+
+    private
+
+    # @param [Array<Fixnum>, Fixnum, Range] value
+    # @return [FalseClass, Range]
+    def to_range(value)
+      case value
+      when Array then (value[0]..value[1])
+      when Fixnum then (0..value)
+      when Range then value
+      end
+    end
+    
+  end
+end

data/test/clock_test.rb

@@ -0,0 +1,51 @@
+require "helper"
+
+class Sequencer::ClockTest < Test::Unit::TestCase
+
+  context "Clock" do
+
+    setup do
+      @clock = Sequencer::Clock.new(120)
+    end
+
+    context "Clock::Event#tick" do
+
+      setup do
+        @flag = false
+        @flag2 = false
+      end
+
+      should "assign single callback" do
+        @clock.event.tick { @flag = true }
+        refute @flag
+        @clock.event.do_tick
+        assert @flag
+      end
+
+      should "reassign single callback" do
+        @clock.event.tick { @flag = true }
+        @clock.event.tick { @flag2 = true }
+        refute @flag
+        refute @flag2
+        @clock.event.do_tick
+        refute @flag
+        assert @flag2
+      end
+
+      should "allow multiple callbacks" do
+        @clock.event.tick { @flag = true }
+        @clock.event.tick << proc { @flag2 = true }
+        refute @flag
+        refute @flag2
+        @clock.event.do_tick
+        assert @flag
+        assert @flag2
+      end
+      
+    end
+
+  end
+
+end
+
+

data/test/core_test.rb

@@ -0,0 +1,133 @@
+require "helper"
+
+class Sequencer::CoreTest < Test::Unit::TestCase
+
+  context "Core" do
+
+    setup do
+      @sequencer = Sequencer::Core.new
+    end
+
+    context "#exec" do
+
+      setup do
+        @sequence = [1,2,3,4]
+      end
+
+      should "move to next" do  
+        assert_equal 0, @sequencer.pointer
+        @sequencer.exec(@sequence)
+        assert_equal 1, @sequencer.pointer
+      end
+
+      should "do repeat" do
+        @sequencer.pointer = @sequence.length - 1
+        @sequencer.exec(@sequence)
+        assert_equal 0, @sequencer.pointer
+      end
+
+      should "stop" do
+        @sequencer.trigger.expects(:stop?).once.returns(true)
+        @sequencer.trigger.expects(:reset?).never
+        @sequencer.event.expects(:do_perform).never
+        @sequencer.exec(@sequence)
+      end
+
+      should "reset and fire event" do
+        @sequencer.pointer = 3
+        @sequencer.trigger.expects(:stop?).once.returns(false)
+        @sequencer.trigger.expects(:reset?).once.returns(true)
+        @sequencer.event.expects(:do_perform).once
+        @sequencer.exec(@sequence)
+        assert_equal 1, @sequencer.pointer
+      end
+
+      should "fire event" do
+        @sequencer.pointer = 2
+        @sequencer.trigger.expects(:stop?).once.returns(false)
+        @sequencer.trigger.expects(:reset?).once.returns(false)
+        @sequencer.event.expects(:do_perform).once
+        @sequencer.exec(@sequence)
+        assert_equal 3, @sequencer.pointer
+      end
+
+    end
+
+    context "#step" do
+
+      setup do
+        @sequence = [1,2,3,4]
+        @sequencer.event.expects(:do_step).once
+      end
+
+      should "move to next" do  
+        assert_equal 0, @sequencer.pointer
+        @sequencer.step(@sequence)
+        assert_equal 1, @sequencer.pointer
+      end
+
+      should "do repeat" do
+        @sequencer.pointer = @sequence.length - 1
+        @sequencer.step(@sequence)
+        assert_equal 0, @sequencer.pointer
+      end
+
+    end
+
+    context "#perform" do
+
+      setup do
+        @sequence = [1,2,3,4]
+      end
+
+      should "stop" do
+        @sequencer.trigger.expects(:stop?).once.returns(true)
+        @sequencer.trigger.expects(:reset?).never
+        @sequencer.event.expects(:do_perform).never
+        @sequencer.perform(@sequence)
+      end
+
+      should "reset and fire event" do
+        @sequencer.pointer = 3
+        @sequencer.trigger.expects(:stop?).once.returns(false)
+        @sequencer.trigger.expects(:reset?).once.returns(true)
+        @sequencer.event.expects(:do_perform).once
+        @sequencer.perform(@sequence)
+        assert_equal 0, @sequencer.pointer
+      end
+
+      should "fire event" do
+        @sequencer.pointer = 3
+        @sequencer.trigger.expects(:stop?).once.returns(false)
+        @sequencer.trigger.expects(:reset?).once.returns(false)
+        @sequencer.event.expects(:do_perform).once
+        @sequencer.perform(@sequence)
+        assert_equal 3, @sequencer.pointer
+      end
+
+    end
+
+    context "Functional" do
+
+      setup do
+        @clock = Sequencer::Clock.new(120)
+        @clock.event.tick { @sequencer.exec(@sequence) }
+        @sequencer.event.stop { @clock.stop }
+        @sequence = [1,2,3,4]
+        @cache = []
+        @sequencer.event.perform { | data| @cache << data }
+        @sequencer.trigger.stop { @sequencer.loop.count == 1 }
+        @clock.start(:focus => true)
+      end
+
+      should "create cache of sequence" do
+        assert_equal @sequence, @cache
+      end
+
+    end
+
+
+  end
+
+end
+

data/test/event_trigger_test.rb

@@ -0,0 +1,89 @@
+require "helper"
+
+class Sequencer::EventTriggerTest < Test::Unit::TestCase
+
+  context "EventTrigger" do
+
+    setup do
+      @trigger = Sequencer::EventTrigger.new
+    end
+
+    context "#reset?" do
+
+      setup do
+        @has_run = false
+        @trigger.reset { |p, d| @has_run = d }
+      end
+
+      should "fire stop trigger" do
+        assert @trigger.reset?(0, true)
+        assert @has_run = true
+      end
+
+    end
+
+    context "#reset_every" do
+
+      setup do
+        @trigger.reset_every(3)
+      end
+
+      should "reset every three ticks" do
+        3.times do |i|
+          assert @trigger.reset?((i * 3) + 0, false)
+          refute @trigger.reset?((i * 3) + 1, false)
+          refute @trigger.reset?((i * 3) + 2, false)
+        end
+      end
+
+    end
+
+    context "#rest_every" do
+
+      setup do
+        @trigger.rest_every(3)
+      end
+
+      should "reset every three ticks" do
+        3.times do |i|
+          assert @trigger.rest?((i * 3) + 0, false)
+          refute @trigger.rest?((i * 3) + 1, false)
+          refute @trigger.rest?((i * 3) + 2, false)
+        end
+      end
+
+    end
+
+    context "#rest?" do
+
+      setup do
+        @has_run = false
+        @trigger.rest { |p, d| @has_run = d }
+      end
+
+      should "fire stop trigger" do
+        assert @trigger.rest?(0, true)
+        assert @has_run = true
+      end
+
+    end
+
+    context "#stop?" do
+
+      setup do
+        @has_run = false
+        @trigger.stop { |p, d| @has_run = d }
+      end
+
+      should "fire stop trigger" do
+        assert @trigger.stop?(0, true)
+        assert @has_run = true
+      end
+
+    end
+
+  end
+
+end
+
+

data/test/helper.rb

@@ -0,0 +1,15 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + "/../lib"
+
+require "test/unit"
+require "mocha/test_unit"
+require "shoulda-context"
+require "sequencer"
+
+module TestHelper
+  
+  def self.select_midi_output
+    $midi_output = UniMIDI::Output.gets
+  end
+         
+end

data/test/loop_test.rb

@@ -0,0 +1,89 @@
+require "helper"
+
+class Sequencer::LoopTest < Test::Unit::TestCase
+
+  context "Loop" do
+
+    setup do
+      @loop = Sequencer::Loop.new
+    end
+
+    context "#to_range" do
+
+      should "convert array" do
+        assert_equal 1..6, @loop.send(:to_range, [1, 6])
+      end
+
+      should "convert number" do
+        assert_equal 0..9, @loop.send(:to_range, 9)
+      end
+
+      should "pass range" do
+        assert_equal 5..8, @loop.send(:to_range, 5..8)
+      end
+
+    end
+
+     context "#start" do
+
+      context "default loop" do
+
+        should "always have 0 as start" do
+          assert @loop.default?
+          assert_equal 0, @loop.start
+        end
+
+      end
+
+      context "custom loop" do
+
+        setup do
+          @loop.range = 3..6
+        end
+
+        should "have custom start point" do
+          refute @loop.default?
+          assert_equal 3, @loop.start
+        end
+
+      end
+
+    end
+
+    context "#in_bounds?" do
+
+      context "default loop" do
+
+        should "include number in range" do
+          assert @loop.in_bounds?(3, :length => 10)
+        end
+
+        should "not include number out of range" do
+          refute @loop.in_bounds?(10, :length => 8)
+        end
+
+      end
+
+      context "custom loop" do
+
+        setup do
+          @loop.range = 0..6
+        end
+
+        should "include number in range" do
+          assert @loop.in_bounds?(5)
+        end
+
+        should "not include number out of range" do
+          refute @loop.in_bounds?(7)
+        end
+
+      end
+
+    end
+
+  end
+
+end
+
+

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: basic-sequencer
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: midi-topaz
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.15
+- !ruby/object:Gem::Dependency
+  name: unimidi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+description: Perform a sequence of events at tempo in Ruby
+email:
+- ari.russo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/sequencer.rb
+- lib/sequencer/clock.rb
+- lib/sequencer/core.rb
+- lib/sequencer/event.rb
+- lib/sequencer/event_trigger.rb
+- lib/sequencer/loop.rb
+- test/clock_test.rb
+- test/core_test.rb
+- test/event_trigger_test.rb
+- test/helper.rb
+- test/loop_test.rb
+homepage: http://github.com/arirusso/sequencer
+licenses:
+- Apache 2.0
+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: 1.3.6
+requirements: []
+rubyforge_project: basic-sequencer
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Perform a sequence of events at tempo
+test_files: []