diamond 0.5.1 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4b95fbd189a76487319f77e97e6d645a75e4dac
-  data.tar.gz: 608fb59532ddca113ea6c29d68ffcbb34211696e
+  metadata.gz: 30e670f044ab17c64cedf2c71573a1a510928cd2
+  data.tar.gz: 0b91f502f5952b2df09f311f1569eb5aa6b061bb
 SHA512:
-  metadata.gz: eb1157bc6dbf55bd3d2b75808a3fd5d12d75db4467d40e42b72b5e7963fe45505ffa9f294417377d354fa1f662d23a86c7e10e0c4eba64084078cf80c197a34d
-  data.tar.gz: fd6dddb843a56ef77845a04155cd99550e60033953fc407e15d0434fd74503777103513fb2c6f06119978a2bcb16f2f679deb9c892bae5dbf7316cefed24dd70
+  metadata.gz: 60f2d5c041101b1bece73255f6cb4416ed5a254afcb971cda4f7de68f1a962f6f1ce8d3ff99fb34fef43b41c404d42581599ee9a45ca74aa71041fa17b5c320f
+  data.tar.gz: d782c0fa28658fd8c8521ae20f17b763e7bc22f9df7a0202ae67711e0494480eee2842ff0f782045c7c3d722fa13d6b39fdc00742f3ed4072f6da74a8e8cdcf4

data/README.md

@@ -1,19 +1,19 @@
-# Diamond
+#Diamond
 
 [MIDI arpeggiator](http://en.wikipedia.org/wiki/Arpeggiator#Arpeggiator) in Ruby
 
 ![diamond](http://img256.imageshack.us/img256/4514/diamondd.jpg)
 
-## Features
+##Features
 
-* Classic arpeggiator functionality
+* Classic arpeggiator functionality and patterns
 * [OSC](http://en.wikipedia.org/wiki/Open_Sound_Control) and MIDI remote control
 * MIDI clock IO
-* Suited to [live coding](http://en.wikipedia.org/wiki/Live_coding)
 * Multiplex clocks and arpeggiators
-* Preset and curstom arpeggio pattern algorithms 
+* Suited to [live coding](http://en.wikipedia.org/wiki/Live_coding)
+* Generative arpeggio patterns 
 
-## Installation
+##Installation
 
 `gem install diamond`
   
@@ -21,13 +21,13 @@
   
 `gem "diamond"` 
   
-## Usage
+##Usage
 
 ```ruby
 require "diamond"
 ```
 
-First, select a MIDI output using [unimidi](https://github.com/arirusso/unimidi). ([more about that...](http://tx81z.blogspot.com/2011/10/selecting-midi-device-with-unimidi.html))
+First, select a MIDI output using [unimidi](https://github.com/arirusso/unimidi). ([more about that here](http://tx81z.blogspot.com/2011/10/selecting-midi-device-with-unimidi.html))
 
 ```ruby
 @output = UniMIDI::Output.gets
@@ -60,7 +60,7 @@ Point the clock to the arpeggiator
 clock << arpeggiator
 ```
 
-Of course, an arpeggiator needs notes to work with. You can use a MIDI input for that. ([see example](http://github.com/arirusso/diamond/blob/master/examples/midi_note_input.rb)). However, again for the sake of simplicity here's a chord in Ruby
+The arpeggiator will play based on inputted notes or chords; a MIDI input can be used for that. ([see example](http://github.com/arirusso/diamond/blob/master/examples/midi_note_input.rb)). It's also possible to enter notes in Ruby:
 
 ```ruby
 chord = ["C3", "G3", "Bb3", "A4"]
@@ -73,15 +73,15 @@ arpeggiator.add(chord)
 arpeggiator << "C5"
 ```
 
-Now we'll start the clock and arpeggiator.  
-
-Note that by default, the clock will run in a background thread. If you're working in a [PRY](http://pryrepl.org)/[IRB](http://en.wikipedia.org/wiki/Interactive_Ruby_Shell)/etc this will allow you to continue to code while the arpeggiator runs. To start in the *foreground*, pass `:focus => true` to `Clock#start`.
+Starting the clock will also start the arpeggiator:
 
 ```ruby
 clock.start
 ```
 
-All of the [arpeggiator options](http://rubydoc.info/github/arirusso/diamond/master/Diamond/Arpeggiator:initialize) can be controlled on the on the fly
+Note that by default, the clock will run in a background thread. If you're working in a [PRY](http://pryrepl.org)/[IRB](http://en.wikipedia.org/wiki/Interactive_Ruby_Shell)/etc this will allow you to continue to code while the arpeggiator runs. To start in the *foreground*, pass `:focus => true` to `Clock#start`.
+
+All of the [arpeggiator options](http://rubydoc.info/github/arirusso/diamond/master/Diamond/Arpeggiator:initialize) can be controlled while the arpeggiator is running.
 
 ```ruby
 arpeggiator.rate = 16
@@ -93,13 +93,13 @@ arpeggiator.remove("C5", "A4")
 
 This [blog post](http://tx81z.blogspot.com/2011/07/live-coding-with-diamond.html) explains what is happening in the video.
 
-#### Posts
+####Posts
 
 * [Introduction](http://tx81z.blogspot.com/2011/07/diamond-midi-arpeggiator-in-ruby.html)
 * [Live coding Diamond and syncing multiple arpeggiators to each other](http://tx81z.blogspot.com/2011/07/live-coding-with-diamond.html)
 * [A note about live coding in IRB with OSX](http://tx81z.blogspot.com/2011/09/note-about-live-coding-in-irb-with-osx.html)
 
-#### Examples
+####Examples
 
 * [Control via OSC](http://github.com/arirusso/diamond/blob/master/examples/osc_control.rb)
 * [Define a Pattern](http://github.com/arirusso/diamond/blob/master/examples/define_pattern.rb)
@@ -111,15 +111,15 @@ This [blog post](http://tx81z.blogspot.com/2011/07/live-coding-with-diamond.html
 
 [More...](http://github.com/arirusso/diamond/blob/master/examples)
  
-## Other Documentation
+##Other Documentation
 
 * [rdoc](http://rubydoc.info/github/arirusso/diamond)
 
-## Author
+##Author
 
 * [Ari Russo](http://github.com/arirusso) <ari.russo at gmail.com>
 
-## License
+##License
 
 Apache 2.0, See the file LICENSE
 

data/lib/diamond.rb

@@ -30,6 +30,6 @@ require "diamond/sequence_parameters"
 
 module Diamond
   
-  VERSION = "0.5.1"
+  VERSION = "0.5.3"
   
 end

data/lib/diamond/arpeggiator.rb

@@ -51,9 +51,9 @@ module Diamond
       transmit_channel = options[:tx_channel]
       devices = MIDIInstrument::Device.partition(options[:midi])
       @midi = MIDI.new(devices, :debug => !!options[:midi_debug], :receive_channel => receive_channel, :transmit_channel => transmit_channel)
-      @midi.enable_output(@sequencer)
-      @midi.enable_note_control(@sequence)
-      @midi.enable_parameter_control(@parameter, options[:midi_control]) if !options[:midi_control].nil?
+      @midi.enable_output(self)
+      @midi.enable_note_control(self)
+      @midi.enable_parameter_control(self, options[:midi_control]) if !options[:midi_control].nil?
       @midi
     end
 
@@ -67,15 +67,6 @@ module Diamond
       @osc
     end
 
-    # Emit any note off messages that are currently pending in the queue.  The clock triggers this 
-    # when stopping or pausing
-    # @return [Array<MIDIMessage::NoteOff>]
-    def emit_pending_note_offs
-      messages = @sequence.pending_note_offs
-      @midi.output.puts(*messages)
-      messages
-    end
-
   end
 
 end

data/lib/diamond/clock.rb

@@ -1,18 +1,26 @@
 module Diamond
 
-  # A wrapper for Sequencer::Clock (and thus Topaz::Tempo) that's geared towards the arpeggiator
+  # A wrapper for Topaz::Tempo that's geared towards the arpeggiator
   class Clock
 
     extend Forwardable
 
-    def_delegators :@clock, :event, :pause, :unpause
+    def_delegators :@clock, :midi_output, :event, :pause, :running?, :tempo, :tempo=, :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(*args)
+    # @option options [Array<UniMIDI::Output>, UniMIDI::Output] :output MIDI output device(s) (also: :outputs)
+    def initialize(tempo_or_input, options = {})
       @arpeggiators = []
-      @clock = Sequencer::Clock.new(*args)
+      output = options[:output] || options[:outputs] || options[:midi]
+      initialize_clock(tempo_or_input, :output => output)
+      initialize_events
+    end
+
+    # Shortcut to the clock's MIDI output devices
+    # @return [Array<UniMIDI::Output>]
+    def midi_outputs
+      @clock.midi_output.devices
     end
 
     # Start the clock
@@ -36,53 +44,52 @@ module Diamond
       true
     end
 
-    # Add an arpeggiator to this clock's control
+    # Add arpeggiator(s) to this clock's control
     # @param [Array<Arpeggiator>, Arpeggiator] arpeggiator
-    # @return [Boolean]
+    # @return [Array<Arpeggiator>]
     def add(arpeggiator)
       arpeggiators = [arpeggiator].flatten
-      result = arpeggiators.map do |arpeggiator|
-        unless @arpeggiators.include?(arpeggiator)
-          @arpeggiators << arpeggiator
-          reset_tick
-          true
-        else
-          false
-        end
-      end
-      result.any?
+      @arpeggiators += arpeggiators
+      @arpeggiators
     end
     alias_method :<<, :add
 
-    # Remove an arpeggiator from this clock's control
-    # @param [Arpeggiator] arpeggiator
-    # @return [Boolean]
+    # Remove arpeggiator(s) from this clock's control
+    # @param [Array<Arpeggiator>, Arpeggiator] arpeggiator
+    # @return [Array<Arpeggiator>]
     def remove(arpeggiator)
       arpeggiators = [arpeggiator].flatten
-      result = arpeggiators.map do |arpeggiator|
-        if @arpeggiators.include?(arpeggiator)
-          @arpeggiators.delete(arpeggiator)
-          reset_tick
-          true
-        else
-          false
-        end
-      end
-      result.any?
+      @arpeggiators.delete_if? { |arpeggiator| arpeggiators.include?(arpeggiator) }
+      @arpeggiators
     end
 
     private
 
-    # Reset the clock's tick event (used when arpeggiators are added or removed)
-    # @return [Array<Arpeggiator>] Arpeggiators that are now actively controlled by this clock
-    def reset_tick
-      @clock.event.tick.clear
-      @arpeggiators.map do |arpeggiator|
-        @clock.event.tick << proc { arpeggiator.sequencer.exec(arpeggiator.sequence) }
-        arpeggiator.sequencer.event.stop { @clock.stop }
-        arpeggiator
+    # @param [Fixnum, UniMIDI::Input] tempo_or_input
+    # @param [Hash] options
+    # @option options [Array<UniMIDI::Output>, UniMIDI::Output] :output MIDI output device(s)
+    # @option options [Fixnum] :resolution
+    # @return [Topaz::Clock]
+    def initialize_clock(tempo_or_input, options = {})
+      @clock = Topaz::Clock.new(tempo_or_input, :midi => options[:output])
+      resolution = options.fetch(:resolution, 128)
+      @clock.interval = @clock.interval * (resolution / @clock.interval)
+      @clock
+    end
+
+    # Initialize the tick event
+    # @return [Boolean]
+    def initialize_events
+      @clock.event.tick << proc do
+        @arpeggiators.each do |arpeggiator|
+          arpeggiator.sequencer.exec(arpeggiator.sequence)
+          arpeggiator.sequencer.event.stop { @clock.stop }
+          arpeggiator
+        end
       end
+      true
     end
+
   end
 
 end

data/lib/diamond/midi.rb

@@ -35,43 +35,43 @@ module Diamond
       end
 
       # Initialize adding and removing MIDI notes from the sequence
-      # @param [Sequence] sequence
+      # @param [Arpeggiator] arpeggiator
       # @return [Boolean]
-      def enable_note_control(sequence)  
+      def enable_note_control(arpeggiator)  
         @midi.input.receive(:class => MIDIMessage::NoteOn) do |event|
           message = event[:message]
           if @midi.input.channel.nil? || @midi.input.channel == message.channel
             puts "[DEBUG] MIDI: add note from input #{message.name} channel: #{message.channel}" if @debug
-            sequence.add(message)
+            arpeggiator.sequence.add(message)
           end
         end 
         @midi.input.receive(:class => MIDIMessage::NoteOff) do |event| 
           message = event[:message]
           if @midi.input.channel.nil? || @midi.input.channel == message.channel
             puts "[DEBUG] MIDI: remove note from input #{message.name} channel: #{message.channel}" if @debug
-            sequence.remove(message)
+            arpeggiator.sequence.remove(message)
           end
         end
         true
       end
 
       # Initialize a user-defined map of control change messages
-      # @param [SequenceParameters] parameters
+      # @param [Arpeggiator] arpeggiator
       # @param [Array<Hash>] map
       # @return [Boolean]
-      def enable_parameter_control(parameters, map)
-        from_range = 0..127
+      def enable_parameter_control(arpeggiator, map)
+        midi_cc_range = 0..127
         @midi.input.receive(:class => MIDIMessage::ControlChange) do |event|
           message = event[:message]
           if @midi.input.channel.nil? || @midi.input.channel == message.channel
             index = message.index
             mapping = map.find { |mapping| mapping[:index] == index }
             property = mapping[:property]
-            to_range = SequenceParameters::RANGE[property]
+            parameter_range = apeggiator.parameter.constraints(property)
             value = message.value
-            value = Scale.transform(value).from(from_range).to(to_range)
+            value = Scale.transform(value).from(midi_cc_range).to(parameter_range)
             puts "[DEBUG] MIDI: #{property}= #{value} channel: #{message.channel}" if @debug
-            parameters.send("#{property}=", value)
+            arpeggiator.parameter.send("#{property}=", value)
           end
         end
       end
@@ -106,10 +106,10 @@ module Diamond
       end
 
       # Initialize MIDI output, enabling the sequencer to emit notes
-      # @param [Sequencer::Core] sequencer
+      # @param [Arpeggiator] arpeggiator
       # @return [Boolean]
-      def enable_output(sequencer)
-        sequencer.event.perform << proc do |bucket|
+      def enable_output(arpeggiator)
+        arpeggiator.sequencer.event.perform << proc do |bucket|
           unless bucket.empty?
             if @debug
               bucket.each do |message|
@@ -119,12 +119,22 @@ module Diamond
             @midi.output.puts(bucket)
           end
         end
-        sequencer.event.stop << proc { emit_pending_note_offs }
+        arpeggiator.sequencer.event.stop << proc { emit_pending_note_offs(arpeggiator) }
         true
       end
 
       private
 
+      # Emit any note off messages that are currently pending in the queue.  The clock triggers this 
+      # when stopping or pausing
+      # @param [Arpeggiator] arpeggiator
+      # @return [Array<MIDIMessage::NoteOff>]
+      def emit_pending_note_offs(arpeggiator)
+        messages = arpeggiator.sequence.pending_note_offs
+        @midi.output.puts(*messages)
+        messages
+      end
+
       # Initialize MIDI output
       # @param [Array<UniMIDI::Output>] outputs
       # @param [Hash] options

data/lib/diamond/osc.rb

@@ -16,20 +16,20 @@ module Diamond
       end
 
       # Enable controlling the instrument via OSC
-      # @param [Object] subject The object to operate on when messages are received
+      # @param [Arpeggiator] arpeggiator The arpeggiator to operate on when messages are received
       # @param [Array<Hash>] map
       # @return [Boolean]
-      def enable_parameter_control(subject, map)
+      def enable_parameter_control(arpeggiator, map)
         start_server
         maps = map.map do |item|
           property = item[:property]
-          from_range = item[:value] || (0..1.0)
-          to_range = SequenceParameters::RANGE[property]
+          osc_range = item[:value] || (0..1.0)
           @server.add_method(item[:address]) do |message|
             value = message.to_a[0]
-            value = Scale.transform(value).from(from_range).to(to_range)
+            parameter_range = arpeggiator.parameter.constraints(property)
+            value = Scale.transform(value).from(osc_range).to(parameter_range)
             puts "[DEBUG]: OSC: #{property}= #{value}" if @debug
-            subject.send("#{property}=", value)
+            arpeggiator.parameter.send("#{property}=", value)
             true
           end
           true

data/lib/diamond/sequence.rb

@@ -21,7 +21,6 @@ module Diamond
     def at(pointer)
       if changed? && (pointer % @parameter.rate == 0)
         update
-        @changed = false
       end
       enqueue_next(pointer)
       messages = @queue.shift || []
@@ -122,6 +121,7 @@ module Diamond
       notes = get_note_sequence
       initialize_sequence(notes.length)
       populate_sequence(notes) unless notes.empty?
+      @changed = false
       @sequence
     end
 

data/lib/diamond/sequence_parameters.rb

@@ -3,15 +3,6 @@ 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,
@@ -38,20 +29,41 @@ module Diamond
       sequence.send(:use_parameters, self)
     end
 
-    # Set the gate property
+    # Dynamically produce an acceptable range for the given param
+    # @param [Symbol] param
+    # @return [Range]
+    def constraints(param)
+      ranges = {
+        :gate => proc { get_lowest_gate..500 },
+        :interval => proc { -48..48 },
+        :pattern_offset => proc { -16..16 },
+        :range => proc { 0..10 },
+        :rate => proc { 0..@resolution },
+        :transpose => proc { -72..72 }
+      }
+      ranges[param].call
+    end
+
+    # Set the gate property. Is constrained to go only as low as the rate and resolution allow.
     # @param [Fixnum] num
+    # @param [Hash] options
+    # @option options [Boolean] :constrain When false, will skip constraints (default: true)
     # @return [Fixnum]
-    def gate=(num)
-      @gate = constrain(num, :range => RANGE[:gate])
+    def gate=(num, options = {})
+      should_constrain = options.fetch(:constrain, true)
+      @gate = should_constrain ? constrain(num, :range => constraints(:gate)) : num
       mark_changed
       @gate
     end
 
     # Set the interval property
     # @param [Fixnum] num
+    # @param [Hash] options
+    # @option options [Boolean] :constrain When false, will skip constraints (default: true)
     # @param [Fixnum]
-    def interval=(num)
-      @interval = num
+    def interval=(num, options = {})
+      should_constrain = options.fetch(:constrain, true)
+      @interval = should_constrain ? constrain(num, :range => constraints(:interval)) : num
       mark_changed
       @interval
     end
@@ -67,18 +79,32 @@ module Diamond
 
     # Set the range property
     # @param [Fixnum] range
+    # @param [Hash] options
+    # @option options [Boolean] :constrain When false, will skip constraints (default: true)
     # @return [Fixnum]
-    def range=(num)
-      @range = constrain(num, :range => RANGE[:range])
+    def range=(num, options = {})
+      should_constrain = options.fetch(:constrain, true)
+      @range = should_constrain ? constrain(num, :range => constraints(:range)) : num
       mark_changed
       @range
     end
 
-    # Set the rate property
+    # Set the rate property. This will also scale the gate accordingly
     # @param [Fixnum] num
+    # @param [Hash] options
+    # @option options [Boolean] :constrain When false, will skip constraints (default: true)
     # @return [Fixnum]
-    def rate=(num)
-      @rate = constrain(num, :range => RANGE[:rate].begin..@resolution)
+    def rate=(num, options = {})
+      # Scale the gate according to the new gate
+      change = num / @rate.to_f
+      new_gate = (@gate * change).ceil
+      if options.fetch(:constrain, true)
+        @rate = constrain(num, :range => constraints(:rate))
+        @gate = constrain(new_gate, :range => constraints(:gate))
+      else
+        @rate = num
+        @gate = new_gate
+      end
       mark_changed
       @rate
     end
@@ -116,6 +142,13 @@ module Diamond
 
     private
 
+    # Find the lowest gate value possible for the rate and resolution
+    # @return [Float]
+    def get_lowest_gate
+      factor = @resolution.to_f / @rate
+      (100.0 / factor).ceil
+    end
+
     # Mark that there's been a change in the sequence
     def mark_changed
       @callback.call
@@ -124,11 +157,11 @@ module Diamond
     # @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])
+      @interval = constrain((options[:interval] || 12), :range => constraints(:interval))
+      @range = constrain((options[:range] || 3), :range => constraints(:range))
+      @pattern_offset = constrain((options[:pattern_offset] || 0),:range => constraints(:pattern_offset))
+      @rate = constrain((options[:rate] || 8), :range => constraints(:rate))
+      @gate = constrain((options[:gate] || 75), :range => constraints(:gate))
       @pattern = get_pattern(options[:pattern])
       self
     end

data/test/arpeggiator_test.rb

@@ -8,6 +8,7 @@ class Diamond::ApeggiatorTest < Test::Unit::TestCase
 
       should "have defaults" do
         @arpeggiator = Diamond::Arpeggiator.new
+        assert_equal 128, @arpeggiator.resolution
         assert_equal 8, @arpeggiator.rate
         assert_equal 3, @arpeggiator.range    
         assert_equal 12, @arpeggiator.interval  
@@ -15,6 +16,7 @@ class Diamond::ApeggiatorTest < Test::Unit::TestCase
 
       should "allow setting params" do
         @arpeggiator = Diamond::Arpeggiator.new(:interval => 7, :range => 4, :rate => 16)
+        assert_equal 128, @arpeggiator.resolution
         assert_equal 16, @arpeggiator.rate
         assert_equal 4, @arpeggiator.range    
         assert_equal 7, @arpeggiator.interval  

data/test/clock_test.rb

@@ -0,0 +1,70 @@
+require "helper"
+
+class Diamond::ClockTest < Test::Unit::TestCase
+
+  context "Clock" do
+
+    setup do
+      @clock = Diamond::Clock.new(120)
+    end
+
+    context "Clock#initialize" do
+
+      should "get MIDI output" do
+        output = Object.new
+        @clock = Diamond::Clock.new(120, :output => output)
+        assert_not_nil @clock.midi_outputs
+        assert_not_empty @clock.midi_outputs
+        assert @clock.midi_outputs.include?(output)
+      end
+
+    end
+
+    context "Clock#add_midi_output" do
+
+      should "add MIDI output" do
+        output = Object.new
+        refute @clock.midi_outputs.include?(output)
+        @clock.midi_output.devices << output
+        assert_not_nil @clock.midi_outputs
+        assert_not_empty @clock.midi_outputs
+        assert @clock.midi_outputs.include?(output)
+      end
+
+    end
+
+    context "Clock#remove_midi_output" do
+
+      should "remove MIDI output" do
+        output = Object.new
+        refute @clock.midi_outputs.include?(output)
+        @clock.midi_output.devices << output
+        assert_not_nil @clock.midi_outputs
+        assert_not_empty @clock.midi_outputs
+        assert @clock.midi_outputs.include?(output)
+
+        @clock.midi_output.devices.delete(output)
+        refute @clock.midi_outputs.include?(output)
+      end
+
+    end
+
+    context "Clock#tempo" do
+
+      should "get tempo" do
+        assert_equal 120, @clock.tempo
+      end
+
+    end
+
+    context "Clock#tempo=" do
+
+      should "set tempo" do
+        @clock.tempo = 58
+        assert_equal 58, @clock.tempo
+      end
+
+    end
+
+  end
+end

data/test/sequence_parameters_test.rb

@@ -6,7 +6,7 @@ class Diamond::SequenceParametersTest < Test::Unit::TestCase
 
     setup do
       @sequence = Diamond::Sequence.new
-      @params = Diamond::SequenceParameters.new(@sequence, 16) { @sequence.mark_changed }
+      @params = Diamond::SequenceParameters.new(@sequence, 128) { @sequence.mark_changed }
     end
 
     context "#rate=" do
@@ -17,6 +17,28 @@ class Diamond::SequenceParametersTest < Test::Unit::TestCase
         assert_equal 16, @params.rate
       end
 
+      should "scale gate down" do
+        @params.rate = 16
+        @params.gate = 50
+        assert_equal 16, @params.rate
+        assert_equal 50, @params.gate
+
+        @params.rate = 8
+        assert_equal 8, @params.rate
+        assert_equal 25, @params.gate
+      end
+
+      should "scale gate up" do
+        @params.rate = 8
+        @params.gate = 50
+        assert_equal 8, @params.rate
+        assert_equal 50, @params.gate
+
+        @params.rate = 16
+        assert_equal 16, @params.rate
+        assert_equal 100, @params.gate
+      end
+
     end
 
     context "#range=" do
@@ -53,6 +75,12 @@ class Diamond::SequenceParametersTest < Test::Unit::TestCase
         assert_equal 125, @params.gate
       end
 
+      should "constrain gate to what rate and resolution allow for" do
+        @params.rate = 16
+        @params.gate = 10
+        assert_equal 13, @params.gate
+      end
+
     end
 
     context "#pattern_offset=" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: diamond
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-18 00:00:00.000000000 Z
+date: 2014-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: analog
@@ -190,6 +190,7 @@ files:
 - lib/diamond/sequence_parameters.rb
 - test/api_test.rb
 - test/arpeggiator_test.rb
+- test/clock_test.rb
 - test/helper.rb
 - test/osc_test.rb
 - test/pattern_test.rb