diamond 0.5.1

data/lib/diamond/sequence_parameters.rb

@@ -0,0 +1,164 @@
+module Diamond
+
+  # User-controller parameters that are used to formulate the note event sequence
+  class SequenceParameters
+
+    RANGE = {
+      :gate => 1..500,
+      :interval => -48..48,
+      :pattern_offset => -16..16,
+      :range => 0..10,
+      :rate => 0..64,
+      :transpose => -64..64
+    }
+
+    attr_reader :gate,
+      :interval,
+      :pattern,
+      :pattern_offset,
+      :range,
+      :rate,
+      :resolution
+
+    # @param [Sequence] sequence
+    # @param [Fixnum] resolution
+    # @param [Hash] options
+    # @option options [Fixnum] :gate Duration of the arpeggiated notes. The value is a percentage based on the rate.  If the rate is 4, then a gate of 100 is equal to a quarter note. (default: 75). must be 1..500
+    # @option options [Fixnum] :interval Increment (pattern) over (interval) scale degrees (range) times.  May be positive or negative. (default: 12)
+    # @option options [Fixnum] :pattern_offset Begin on the nth note of the sequence (but not omit any notes). (default: 0)
+    # @option options [String, Pattern] :pattern Computes the contour of the arpeggiated melody.  Can be the name of a pattern or a pattern object.
+    # @option options [Fixnum] :range Increment the (pattern) over (interval) scale degrees (range) times. Must be positive (abs will be used). (default: 3)
+    # @option options [Fixnum] :rate How fast the arpeggios will be played. Must be positive (abs will be used). (default: 8, eighth note.) must be 0..resolution
+    # @param [Proc] callback
+    def initialize(sequence, resolution, options = {}, &callback)
+      @transpose = 0
+      @resolution = resolution
+      @callback = callback
+      apply_options(options)
+      sequence.send(:use_parameters, self)
+    end
+
+    # Set the gate property
+    # @param [Fixnum] num
+    # @return [Fixnum]
+    def gate=(num)
+      @gate = constrain(num, :range => RANGE[:gate])
+      mark_changed
+      @gate
+    end
+
+    # Set the interval property
+    # @param [Fixnum] num
+    # @param [Fixnum]
+    def interval=(num)
+      @interval = num
+      mark_changed
+      @interval
+    end
+
+    # Set the pattern offset property
+    # @param [Fixnum] num
+    # @return [Fixnum]
+    def pattern_offset=(num)
+      @pattern_offset = num
+      mark_changed
+      @pattern_offset
+    end
+
+    # Set the range property
+    # @param [Fixnum] range
+    # @return [Fixnum]
+    def range=(num)
+      @range = constrain(num, :range => RANGE[:range])
+      mark_changed
+      @range
+    end
+
+    # Set the rate property
+    # @param [Fixnum] num
+    # @return [Fixnum]
+    def rate=(num)
+      @rate = constrain(num, :range => RANGE[:rate].begin..@resolution)
+      mark_changed
+      @rate
+    end
+
+    # Set the pattern property
+    # @param [Pattern] pattern
+    # @return [Pattern]
+    def pattern=(pattern)
+      @pattern = pattern
+      mark_changed
+      @pattern
+    end
+
+    # Transpose everything by the given number of scale degrees. Can be used as a getter
+    # @param [Fixnum, nil] num
+    # @return [Fixnum, nil]
+    def transpose(num = nil)
+      @transpose = num unless num.nil?
+      mark_changed
+      @transpose      
+    end
+    alias_method :transpose=, :transpose
+
+    # The computed pattern given the sequence options
+    # @return [Array<Fixnum>]
+    def computed_pattern
+      @pattern.compute(@range, @interval)
+    end
+
+    # The note duration given the sequence options
+    # @return [Numeric]
+    def duration
+      @resolution / @rate
+    end
+
+    private
+
+    # Mark that there's been a change in the sequence
+    def mark_changed
+      @callback.call
+    end
+
+    # @param [Hash] options
+    # @return [ArpeggiatorSequence::Parameters]
+    def apply_options(options)
+      @interval = constrain((options[:interval] || 12), :range => RANGE[:interval])
+      @range = constrain((options[:range] || 3), :range => RANGE[:range])
+      @pattern_offset = constrain((options[:pattern_offset] || 0),:range => RANGE[:pattern_offset])
+      @rate = constrain((options[:rate] || 8), :range => 0..@resolution)
+      @gate = constrain((options[:gate] || 75), :range => RANGE[:gate])
+      @pattern = get_pattern(options[:pattern])
+      self
+    end
+
+    # Derive a pattern from the options or using the default
+    # @param [Pattern, String, nil] option
+    # @return [Pattern, nil]
+    def get_pattern(option)
+      @pattern = case option
+                 when Pattern then option
+                 when String then Pattern.find(option)
+                 end
+      @pattern ||= Pattern.first
+    end
+
+    # Constrain the given value based on the sequence options
+    # @param [Numeric] value
+    # @param [Hash] options
+    # @option options [Numeric] :min
+    # @option options [Numeric] :max
+    # @option options [Range] :range
+    # @return [Numeric]
+    def constrain(value, options = {})
+      min = options[:range].nil? ? options[:min] : options[:range].begin
+      max = options[:range].nil? ? options[:max] : options[:range].end
+      new_value = value
+      new_value = min.nil? ? new_value : [new_value, min].max
+      new_value = max.nil? ? new_value : [new_value, max].min
+      new_value
+    end
+
+  end
+end

data/test/api_test.rb

@@ -0,0 +1,152 @@
+require "helper"
+
+class Diamond::APITest < Test::Unit::TestCase
+
+  context "API" do
+
+    context "MIDI" do
+
+      context "#omni_on" do
+
+        setup do
+          @messages = [
+            MIDIMessage::NoteOn["C4"].new(10, 100),
+            MIDIMessage::NoteOn["C4"].new(3, 100),
+            MIDIMessage::NoteOn["C4"].new(2, 100)
+          ]
+          @arpeggiator = Diamond::Arpeggiator.new(:rx_channel => 3)
+        end
+
+        should "not acknowledge message with wrong rx channel" do
+          @arpeggiator.add(@messages[0])
+          assert_empty @arpeggiator.sequence.instance_variable_get("@input_queue")
+        end
+
+        should "acknowledge message with rx channel" do
+          @arpeggiator.add(@messages[1])
+          @arpeggiator.sequence.instance_variable_get("@input_queue").expects(:concat).once.with([@messages[1]])
+        end
+
+        should "with omni on, acknowledge any rx channel" do
+          @arpeggiator.omni_on
+          @arpeggiator.add(@messages[2])
+          @arpeggiator.sequence.instance_variable_get("@input_queue").expects(:concat).once.with([@messages[2]]) 
+        end
+
+      end
+
+      context "#add_midi_source" do
+
+        setup do
+          @input = $test_device[:input]
+          @arpeggiator = Diamond::Arpeggiator.new
+          refute @arpeggiator.midi_sources.include?(@input)
+        end
+
+        should "add a midi source" do
+          @arpeggiator.add_midi_source(@input)
+          assert_not_empty @arpeggiator.midi_sources
+          assert @arpeggiator.midi_sources.include?(@input)
+        end
+
+      end
+
+      context "#remove_midi_source" do
+
+        setup do
+          @input = $test_device[:input]
+          @arpeggiator = Diamond::Arpeggiator.new
+          @arpeggiator.add_midi_source(@input)
+          assert_not_empty @arpeggiator.midi_sources
+          assert @arpeggiator.midi_sources.include?(@input)
+        end
+
+        should "remove a midi source" do
+          @arpeggiator.remove_midi_source(@input)
+          refute @arpeggiator.midi_sources.include?(@input)
+        end
+
+      end
+
+      context "#mute" do
+
+        setup do
+          @arpeggiator = Diamond::Arpeggiator.new
+        end
+
+        should "mute the arpeggiator" do
+          refute @arpeggiator.muted?     
+          @arpeggiator.mute = true
+          assert @arpeggiator.muted?
+          @arpeggiator.mute = false
+          refute @arpeggiator.muted?
+          @arpeggiator.toggle_mute
+          assert @arpeggiator.muted?
+        end
+
+      end
+
+    end
+
+    context "SequenceParameters" do
+
+      setup do
+        @arpeggiator = Diamond::Arpeggiator.new
+      end
+
+      context "#rate=" do
+
+        should "set the rate" do
+          assert_not_equal 16, @arpeggiator.rate
+          @arpeggiator.rate = 16
+          assert_equal 16, @arpeggiator.rate
+        end
+
+      end
+
+      context "#range=" do
+
+        should "set the range" do
+          @arpeggiator.range = 4
+          assert_equal 4, @arpeggiator.range
+          @arpeggiator.range += 1
+          assert_equal 5, @arpeggiator.range 
+        end
+
+      end
+
+      context "#interval=" do
+
+        should "set the interval" do
+          assert_not_equal 7, @arpeggiator.interval
+          @arpeggiator.interval = 7
+          assert_equal 7, @arpeggiator.interval 
+        end
+
+      end
+
+      context "#gate=" do
+
+        should "set the gate" do
+          assert_not_equal 125, @arpeggiator.gate
+          @arpeggiator.gate = 125
+          assert_equal 125, @arpeggiator.gate 
+        end
+
+      end
+
+      context "#pattern_offset=" do
+
+        should "set the offset" do
+          assert_not_equal 5, @arpeggiator.pattern_offset
+          @arpeggiator.pattern_offset = 5
+          assert_equal 5, @arpeggiator.pattern_offset
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/arpeggiator_test.rb

@@ -0,0 +1,34 @@
+require "helper"
+
+class Diamond::ApeggiatorTest < Test::Unit::TestCase
+
+  context "Arpeggiator" do
+
+    context "#initialize" do
+
+      should "have defaults" do
+        @arpeggiator = Diamond::Arpeggiator.new
+        assert_equal 8, @arpeggiator.rate
+        assert_equal 3, @arpeggiator.range    
+        assert_equal 12, @arpeggiator.interval  
+      end
+
+      should "allow setting params" do
+        @arpeggiator = Diamond::Arpeggiator.new(:interval => 7, :range => 4, :rate => 16)
+        assert_equal 16, @arpeggiator.rate
+        assert_equal 4, @arpeggiator.range    
+        assert_equal 7, @arpeggiator.interval  
+      end
+
+      should "allow passing in input" do
+        @input = $test_device[:input]
+        @arpeggiator = Diamond::Arpeggiator.new(:midi => @input)
+        assert_not_empty @arpeggiator.midi_sources
+        assert @arpeggiator.midi_sources.include?(@input) 
+      end
+
+    end
+
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,23 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + "/../lib"
+
+require "test/unit"
+require "mocha/test_unit"
+require "shoulda-context"
+require "diamond"
+
+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
+
+TestHelper.select_devices
+
+# Stub out OSC networking
+::EM.stubs(:run).returns(:true)

data/test/osc_test.rb

@@ -0,0 +1,37 @@
+require "helper"
+
+class Diamond::OSCTest < Test::Unit::TestCase
+
+  context "OSC" do
+
+    context "#enable_parameter_control" do
+
+      setup do
+        @map = [
+         { :property => :interval, :address => "/1/rotaryA", :value => (0..1.0) },
+         { :property => :transpose, :address => "/1/rotaryB" }
+        ]
+        @addresses = @map.map { |mapping| mapping[:address] }
+        @osc = Diamond::OSC.new(:server_port => 8000)
+      end
+
+      should "start server" do
+        ::OSC::EMServer.any_instance.expects(:run).once
+        @osc.enable_parameter_control(Object.new, @map)
+        ::OSC::EMServer.any_instance.unstub(:run)
+      end
+
+      should "assign map" do
+        ::OSC::EMServer.any_instance.expects(:add_method).times(@map.size).with do |arg| 
+          assert @addresses.include?(arg)
+        end
+        @osc.enable_parameter_control(Object.new, @map)
+        ::OSC::EMServer.any_instance.unstub(:add_method)
+      end
+
+    end
+
+  end
+
+end
+

data/test/pattern_test.rb

@@ -0,0 +1,63 @@
+require "helper"
+
+class PatternTest < Test::Unit::TestCase
+
+  context "Pattern" do
+
+    setup do
+      ::OSC::EMServer.any_instance.stubs(:run).returns(:true)
+    end
+
+    context "#initialize" do
+
+      should "create usable pattern" do
+        pattern = Diamond::Pattern.new("test") do |range, interval|
+          0.upto(range).map { |num| num * interval }
+        end
+        result = pattern.compute(2, 12)
+        assert_equal [0, 12, 24], result
+      end
+
+    end
+
+    context "#compute" do
+
+      should "reflect range and interval" do
+        pattern = Diamond::Pattern.find("Up")
+        result = pattern.compute(3, 7)
+        assert_equal 4, result.length
+        assert_equal [0, 7, 14, 21], result        
+      end
+
+    end
+    context "Presets" do
+
+      should "populate Up" do
+        pattern = Diamond::Pattern.find("Up")
+        result = pattern.compute(2, 12)
+        assert_equal [0, 12, 24], result    
+      end
+
+      should "populate Down" do
+        pattern = Diamond::Pattern.find("Down")
+        result = pattern.compute(2, 12)
+        assert_equal [24, 12, 0], result  
+      end
+
+      should "populate UpDown" do
+        pattern = Diamond::Pattern.find("UpDown")
+        result = pattern.compute(3, 12)
+        assert_equal [0, 12, 24, 36, 24, 12, 0], result   
+      end
+
+      should "populate DownUp" do
+        pattern = Diamond::Pattern.find("DownUp")
+        result = pattern.compute(3, 12)
+        assert_equal [36, 24, 12, 0, 12, 24, 36], result   
+      end
+
+    end
+
+  end
+
+end