musicality 0.11.1 → 0.12.0

data/lib/musicality/performance/supercollider/synthdefs/pianos.rb

@@ -0,0 +1,46 @@
+module Musicality
+module SuperCollider
+module SynthDefs
+
+CHEAP_PIANO = SynthDef.new(name: "cheappiano", params: { :out => 0, :freq => 440, :amp => 1, :dur => 1, :gate => 1, :pan => 0 },
+  body: <<-SCLANG,
+  var sig, in, n = 6, max = 0.04, min = 0.01, delay, pitch, detune, hammer;
+  freq = freq.cpsmidi;
+  hammer = Decay2.ar(Impulse.ar(0.001), 0.008, 0.04, LFNoise2.ar([2000,4000].asSpec.map(amp), 0.25));
+  sig = Mix.ar(Array.fill(3, { arg i;
+      detune = #[-0.04, 0, 0.03].at(i);
+      delay = (1/(freq + detune).midicps);
+      CombL.ar(hammer, delay, delay, 50 * amp)
+    }) );
+
+  sig = HPF.ar(sig,50) * EnvGen.ar(Env.perc(0.0001,dur, amp * 4, -1), gate: gate, doneAction:2);
+  Out.ar(out, Pan2.ar(sig, pan));
+SCLANG
+  credit: "based on something posted 2008-06-17 by jeff, based on an old example by james mcc",
+  source: "https://github.com/supercollider-quarks/SynthDefPool",
+)
+
+EVERYTHING_RHODES = SynthDef.new(name: "everythingrhodes", params: { :out => 0, :freq => 440, :amp => 0.1, :gate => 1,
+    :lforate => 1.85, :lfowidth => 0.5, :cutoff => 2000, :rq => 0.2, :pan => 0.0 },
+  body: <<-SCLANG,
+  var pulse, filter, env;
+
+  pulse = Pulse.ar(freq*[1,33.5.midiratio],[0.2,0.1],[0.7,0.3]);
+  env = EnvGen.ar(Env.adsr(0.0,1.0,0.8,3.0),gate,doneAction:2);
+  //keyboard tracking filter cutoff
+  filter = BLowPass4.ar(pulse,(cutoff*(env.squared))+200+freq,rq);
+
+  Out.ar(out,Pan2.ar(Mix(filter)*env*amp,pan));
+SCLANG
+  credit: <<-EOS,
+Sound recipes from:
+Mitchell Sigman (2011) Steal this Sound. Milwaukee, WI: Hal Leonard Books
+adapted for SuperCollider and elaborated by Nick Collins (http://www.sussex.ac.uk/Users/nc81/index.html)
+under GNU GPL 3  as per SuperCollider license
+EOS
+  source: "https://github.com/acarabott/roundhouse-synth-design-course-2014",
+)
+
+end
+end
+end

data/lib/musicality/performance/supercollider/synthdefs/snares.rb

@@ -0,0 +1,169 @@
+module Musicality
+module SuperCollider
+module SynthDefs
+
+SNARE1 = SynthDef.new(name: "snare1", params: { :out => 0, :amp => 0.8 },
+  body: <<-SCLANG,
+  var env0, env1, env2, env1m, oscs, noise, sig;
+
+  env0 = EnvGen.ar(Env([0.5, 1, 0.5, 0], [0.005, 0.03, 0.10], [-4, -2, -4]));
+  env1 = EnvGen.ar(Env([110, 60, 49], [0.005, 0.1], [-4, -5]));
+  env1m = env1.midicps;
+  env2 = EnvGen.ar(Env([1, 0.4, 0], [0.05, 0.13], [-2, -2]), doneAction:2);
+
+  oscs = LFPulse.ar(env1m, 0, 0.5, 1, -0.5) +
+  LFPulse.ar(env1m * 1.6, 0, 0.5, 0.5, -0.25);
+  oscs = LPF.ar(oscs, env1m * 1.2, env0);
+  oscs = oscs + SinOsc.ar(env1m, 0.8, env0);
+
+  noise = WhiteNoise.ar(0.2);
+  noise = HPF.ar(noise, 200, 2);
+  noise = BPF.ar(noise, 6900, 0.6, 3) + noise;
+  noise = noise * env2;
+
+  sig = oscs + noise;
+  sig = sig.clip2(1) * amp;
+
+  Out.ar(out, sig.dup);
+SCLANG
+  source: "https://github.com/acarabott/roundhouse-synth-design-course-2014",
+)
+
+SNARE2 = SynthDef.new(name: "snare2", params: { :sfreq => 1500, :out => 0 },
+  body: <<-SCLANG,
+  var tri = Mix([LFTri.ar([111, 175, 224])]) * 0.5;
+  var sine = Mix([SinOsc.ar([330, 180])]) * 0.5;
+  var env = EnvGen.ar(Env.perc(0.01, 0.2), doneAction:2);
+  var snares = WhiteNoise.ar(1);
+  var snareEnv = EnvGen.ar(Env.perc(0.01, 0.2));
+
+  snares = HPF.ar(snares, sfreq);
+  snares = snares * snareEnv;
+
+  Out.ar(out, Mix([tri, sine, snares]) * env);
+SCLANG
+  credit: "Based on Sound on Sound Synth Secrets 35, by Arthur Carabott",
+  source: "https://github.com/acarabott/roundhouse-synth-design-course-2014",
+)
+
+SOS_SNARE = SynthDef.new(name: "SOSsnare", params: { :out => 0, :decay => 0.12, :drum_mode_level => 0.25, :snare_level => 40, :snare_tightness => 3000, :freq => 405, :amp => 0.8 },
+  body: <<-SCLANG,
+  var drum_mode_sin_1, drum_mode_sin_2, drum_mode_pmosc, drum_mode_mix,
+drum_mode_env;
+  var snare_noise, snare_brf_1, snare_brf_2, snare_brf_3, snare_brf_4,
+snare_reson;
+  var snare_env;
+  var snare_drum_mix;
+
+  drum_mode_env = EnvGen.ar(Env.perc(0.005, decay), 1.0, doneAction: 2);
+  drum_mode_sin_1 = SinOsc.ar(freq*0.53, 0, drum_mode_env * 0.5);
+  drum_mode_sin_2 = SinOsc.ar(freq, 0, drum_mode_env * 0.5);
+  drum_mode_pmosc = PMOsc.ar( Saw.ar(freq*0.85), 184, 0.5/1.3, mul: drum_mode_env*5, add: 0);
+  drum_mode_mix = Mix.new([drum_mode_sin_1, drum_mode_sin_2, drum_mode_pmosc]) * drum_mode_level;
+
+  // choose either noise source below
+  //  snare_noise = Crackle.ar(2.01, 1);
+  snare_noise = LFNoise0.ar(20000, 0.1);
+  snare_env = EnvGen.ar(Env.perc(0.005, decay, curve:-5), 1.0, doneAction: 2);
+  snare_brf_1 = BRF.ar(in: snare_noise, freq: 8000, mul: 0.5, rq: 0.1);
+  snare_brf_2 = BRF.ar(in: snare_brf_1, freq: 5000, mul: 0.5, rq: 0.1);
+  snare_brf_3 = BRF.ar(in: snare_brf_2, freq: 3600, mul: 0.5, rq: 0.1);
+  snare_brf_4 = BRF.ar(in: snare_brf_3, freq: 2000, mul: snare_env, rq: 0.0001);
+  snare_reson = Resonz.ar(snare_brf_4, snare_tightness, mul: snare_level) ;
+  snare_drum_mix = Mix.new([drum_mode_mix, snare_reson]) * 5 * amp;
+  Out.ar(out, [snare_drum_mix, snare_drum_mix])
+SCLANG
+  credit: "recipe basically from Gordon Reid
+http://www.soundonsound.com/sos/Mar02/articles/synthsecrets0302.asp
+programmed by Renick Bell, renick_at_gmail.com",
+  source: "https://github.com/willieavendano/SC-SynthDefs/blob/master/DrumMachines",
+)
+
+SNARE_OTO_309 = SynthDef.new(name: "snare_oto309", params: { :out => 0, :amp => 0.1, :pan => 0 },
+  body: <<-SCLANG,
+  var env0, env1, env2, env1m, oscs, noise, son;
+
+  env0 = EnvGen.ar(Env.new([0.5, 1, 0.5, 0], [0.005, 0.03, 0.10], [-4, -2, -4]));
+  env1 = EnvGen.ar(Env.new([110, 60, 49], [0.005, 0.1], [-4, -5]));
+  env1m = env1.midicps;
+  env2 = EnvGen.ar(Env.new([1, 0.4, 0], [0.05, 0.13], [-2, -2]), doneAction:2);
+
+  oscs = LFPulse.ar(env1m, 0, 0.5, 1, -0.5) + LFPulse.ar(env1m * 1.6, 0, 0.5, 0.5, -0.25);
+  oscs = LPF.ar(oscs, env1m*1.2, env0);
+  oscs = oscs + SinOsc.ar(env1m, 0.8, env0);
+
+  noise = WhiteNoise.ar(0.2);
+  noise = HPF.ar(noise, 200, 2);
+  noise = BPF.ar(noise, 6900, 0.6, 3) + noise;
+  noise = noise * env2;
+
+  son = oscs + noise;
+  son = son.clip2(1) * amp;
+
+  Out.ar(out, Pan2.ar(son, pan));
+SCLANG
+  credit: "from 08091500Acid309 by_otophilia",
+  source: "https://github.com/supercollider-quarks/SynthDefPool",
+)
+
+SNARE_STEIN = SynthDef.new(name: "snare_stein", params: { :out => 0, :amp => 0.1, :pan => 0 },
+  body: <<-SCLANG,
+  var snare, filtWhite;
+
+  filtWhite = LPF.ar(WhiteNoise.ar(1), 7040, 1);
+
+  snare = (SinOsc.ar(330,0,0.25) * EnvGen.ar(Env.perc(0.0005,0.055))) + (SinOsc.ar(185,0,0.25) * EnvGen.ar(Env.perc(0.0005,0.075))) + (filtWhite * EnvGen.ar(Env.perc(0.0005,0.2), doneAction: 2) * 0.2) + (HPF.ar(filtWhite, 523, 1) * EnvGen.ar(Env.perc(0.0005,0.183)) * 0.2);
+  Out.ar(out, Pan2.ar(snare * amp * 10, pan));
+SCLANG
+  credit: "Snare written by Esben Stein, I believe",
+  source: "https://github.com/supercollider-quarks/SynthDefPool",
+)
+
+SNARE3 = SynthDef.new(name: "snare", params: { :amp => 1, :dur => 0.05, :out => 0 },
+  body: <<-SCLANG,
+dur = dur * 16;
+Out.ar(out, amp * XLine.ar(2,1/1000,dur) * BPF.ar(PinkNoise.ar(0.8), XLine.ar(20000,1000,dur, doneAction:2), 0.8).dup);
+SCLANG
+  source: "https://github.com/bwestergard/supercollider-experiments",
+)
+
+SNARE_909 = SynthDef.new(name: "snare909", params: { :out => 0, :lpFreq => 1000, :vol => 1, :gate => 1 },
+  body: <<-SCLANG,
+  var sig1, sig2;
+  var triEnv;
+  var shifted1;
+  var shifted2;
+  var sinEnv;
+  var sin1, sin2;
+  var mixed;
+  var sig3;
+  var noiseEnv;
+
+  // tri -> final mixer
+  triEnv = Env.adsr(0, 0.4, 0, 0, curve: -4,  peakLevel: 0.5);
+  sig1 = LFTri.ar(111, 0, 0.5) * EnvGen.kr(triEnv, gate: gate, doneAction: 2);
+  shifted1 = FreqShift.ar(sig1, 175);
+  shifted2 = FreqShift.ar(sig1, 224);
+  sig1 = Mix.new([shifted1, shifted2]);
+
+  // sines -> final mixer
+  sin1 = SinOsc.ar(330, mul: 0.2);
+  sin2 = SinOsc.ar(180, mul: 0.2);
+  sinEnv = Env.adsr(0, 0.2, 0, 0);
+  sig2 = Mix.new([sin1, sin2]) * EnvGen.kr(sinEnv, gate: gate, doneAction: 2);
+
+  // noise -> final mixer
+  noiseEnv = Env.adsr(0, 0.3, 0, 0);
+  sig3 = LPF.ar(WhiteNoise.ar() * EnvGen.kr(noiseEnv, gate: gate, doneAction: 2), 1000);
+  sig3 = HPF.ar(sig3, 600);
+
+  mixed = Mix.new([sig1, sig2, sig3]);
+  mixed = LPF.ar(mixed, lpFreq) * vol;
+  Out.ar(out, mixed  ! 2);
+SCLANG
+  source: "https://github.com/mattvears/supercollider-stuff",
+)
+
+end
+end
+end

data/lib/musicality/performance/supercollider/synthdefs/toms.rb

@@ -0,0 +1,25 @@
+module Musicality
+module SuperCollider
+module SynthDefs
+
+TOM1 = SynthDef.new(name: "tom1", params: { :out => 0, :freq => 200, :amp => 1, :pan => 0.0 },
+  body: <<-SCLANG,
+  var env, tom;
+  env = EnvGen.kr(Env.perc(0.001, 0.1, 1, -5), 1, doneAction:2);
+  tom = SinOsc.ar(freq) * env;
+  Out.ar(out, Pan2.ar(tom, pan, amp));
+SCLANG
+  source: "http://superdupercollider.blogspot.com/2009/02/simple-drum-machine.html"
+)
+
+FM_TOM = SynthDef.new(name: "fmtom", params: { :out => 0, :freq => 200, :gate => 1, :amp => 1 },
+  body: <<-SCLANG,
+  var tom = PMOsc.ar(freq, 280, Line.kr(0.0, 12, 1), mul: EnvGen.ar(Env.adsr(0.003,0.2,0,0), gate, levelScale: 0.3, doneAction: 2));
+  Out.ar(out, tom * amp ! 2);
+SCLANG
+  source: "https://github.com/mattvears/supercollider-stuff",
+)
+
+end
+end
+end

data/lib/musicality/performance/supercollider/synthdefs/volume.rb

@@ -0,0 +1,20 @@
+module Musicality
+module SuperCollider
+module SynthDefs
+
+VOLUME_CONTROL = SynthDef.new(name: "volume_control", params: { :in => nil, :out => nil, :control => nil },
+  body: <<-SCLANG,
+  var sig = In.ar([in,in+1]) * In.kr(control);
+  Out.ar(out,sig);
+SCLANG
+  credit: "James Tunnell",
+)
+
+VOLUME_CHANGE = SynthDef.new(name: "volume_change", params: { :vol_bus => nil, :vol => nil, :dur => nil },
+  body: "  Out.kr(vol_bus, Line.kr(In.kr(vol_bus), vol, dur));",
+  credit: "James Tunnell",
+)
+
+end
+end
+end

data/lib/musicality/pitch_class.rb

@@ -20,7 +20,7 @@ end
 
 end
 
-class Fixnum
+class Integer
   def to_pc
     PitchClass.from_i self
   end

data/lib/musicality/pitch_classes.rb

@@ -1,6 +1,6 @@
 module Musicality
 
-module PitchClasses  
+module PitchClasses
   C = Bs = 0
   Cs = Db = 1
   D = 2
@@ -15,8 +15,6 @@ module PitchClasses
   B = Cb = 11
 end
 
-PITCH_CLASSES = PitchClasses.constants.map do |sym|
-  PitchClasses.const_get(sym)
-end.sort
+PITCH_CLASSES = PitchClasses.constants.map { |sym| PitchClasses.const_get(sym) }.sort
 
-end
+end

data/lib/musicality/version.rb

@@ -1,3 +1,3 @@
 module Musicality
-  VERSION = "0.11.1"
+  VERSION = "0.12.0"
 end

data/lib/musicality.rb

@@ -38,6 +38,7 @@ require 'musicality/notation/parsing/numbers/nonnegative_float_parsing'
 require 'musicality/notation/parsing/numbers/nonnegative_rational_parsing'
 require 'musicality/notation/parsing/pitch_parsing'
 require 'musicality/notation/parsing/pitch_node'
+require 'musicality/notation/parsing/key_parsing'
 require 'musicality/notation/parsing/duration_parsing'
 require 'musicality/notation/parsing/duration_nodes'
 require 'musicality/notation/parsing/articulation_parsing'
@@ -78,6 +79,18 @@ require 'musicality/composition/util/note_generation'
 require 'musicality/composition/model/scale'
 require 'musicality/composition/model/scale_class'
 require 'musicality/composition/model/scale_classes'
+require 'musicality/composition/model/rhythm_class'
+require 'musicality/composition/model/rhythm'
+
+require 'musicality/composition/sequencing/sequenceable'
+require 'musicality/composition/sequencing/note_fifo'
+require 'musicality/composition/sequencing/sequencer'
+require 'musicality/composition/sequencing/note_array'
+require 'musicality/composition/sequencing/drum_machine/drum_parts'
+require 'musicality/composition/sequencing/drum_machine/drum_pattern'
+require 'musicality/composition/sequencing/drum_machine/drum_patterns/pop_drum_patterns'
+require 'musicality/composition/sequencing/drum_machine/drum_kit'
+require 'musicality/composition/sequencing/drum_machine/drum_machine'
 
 require 'musicality/composition/generation/counterpoint_generator'
 require 'musicality/composition/generation/random_rhythm_generator'
@@ -121,10 +134,21 @@ require 'musicality/performance/supercollider/node'
 require 'musicality/performance/supercollider/synth'
 require 'musicality/performance/supercollider/group'
 require 'musicality/performance/supercollider/synthdef'
-require 'musicality/performance/supercollider/synthdefs'
+require 'musicality/performance/supercollider/synthdefs/bass'
+require 'musicality/performance/supercollider/synthdefs/claps'
+require 'musicality/performance/supercollider/synthdefs/cymbals'
+require 'musicality/performance/supercollider/synthdefs/hihats'
+require 'musicality/performance/supercollider/synthdefs/kicks'
+require 'musicality/performance/supercollider/synthdefs/mario'
+require 'musicality/performance/supercollider/synthdefs/other'
+require 'musicality/performance/supercollider/synthdefs/pianos'
+require 'musicality/performance/supercollider/synthdefs/snares'
+require 'musicality/performance/supercollider/synthdefs/toms'
+require 'musicality/performance/supercollider/synthdefs/volume'
 require 'musicality/performance/supercollider/performer'
 require 'musicality/performance/supercollider/conductor'
 require 'musicality/performance/supercollider/score_conducting'
+require 'musicality/performance/supercollider/sc_drum_kits'
 
 #
 # Printing

data/musicality.gemspec

@@ -22,10 +22,11 @@ SuperCollider."
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 2.9"
+  spec.add_development_dependency "rspec", "~> 3.5"
   spec.add_development_dependency "pry"
+  spec.add_development_dependency "coveralls", '~> 0.8'
 
   spec.add_dependency "treetop", "~> 1.5"
   spec.add_dependency 'midilib', '~> 2.0'

data/spec/composition/convenience_methods_spec.rb

@@ -5,12 +5,12 @@ describe 'transpose' do
     notes = "/4A2,C2 /4D2,F2,Gb2 /8 /8E4".to_notes
     semitones = 3
     notes2 = transpose(notes,semitones)
-    
-    notes2.size.should eq(notes.size)
+
+    expect(notes2.size).to eq(notes.size)
     notes2.each_index do |i|
       notes2[i].pitches.each_with_index do |pitch2,j|
         pitch = notes[i].pitches[j]
-        pitch2.diff(pitch).should eq(semitones)
+        expect(pitch2.diff(pitch)).to eq(semitones)
       end
     end
   end
@@ -30,19 +30,19 @@ end
   describe method do
     context 'given no args' do
       it 'should produce an empty array' do
-        send(method).should eq([])
+        expect(send(method)).to eq([])
       end
     end
 
     context 'given one pitch' do
       it 'should produce an array with one note, with proper duration' do
-        send(method,*[C2]).should eq([Note.new(dur,C2)])
+        expect(send(method,*[C2])).to eq([Note.new(dur,C2)])
       end
     end
 
     context 'given one pitch group' do
       it 'should produce an array with one note, given pitch group, and with proper duration' do
-        send(method,*[[C2,E2,G2]]).should eq([Note.new(dur,[C2,E2,G2])])
+        expect(send(method,*[[C2,E2,G2]])).to eq([Note.new(dur,[C2,E2,G2])])
       end
     end
 
@@ -51,10 +51,10 @@ end
         pg1 = A3
         pg2 = [B3,G3]
         pg3 = F4
-        send(method,*[pg1,pg2,pg3]).should eq([
+        expect(send(method,*[pg1,pg2,pg3])).to eq([
           Note.new(dur,pg1), Note.new(dur,pg2), Note.new(dur,pg3)
         ])
       end
     end
   end
-end
+end

data/spec/composition/generation/random_rhythm_generator_spec.rb

@@ -13,27 +13,27 @@ describe RandomRhythmGenerator do
       end
     end
   end
-  
+
   before :all do
     @rrgs = [
       { 1/8.to_r => 0.25, 1/4.to_r => 0.5, 1/2.to_r => 0.25 },
       { 1/6.to_r => 0.25, 1/4.to_r => 0.25, 1/3.to_r => 0.25, 1/12.to_r => 0.25 }
     ].map {|durs_w_probs| RandomRhythmGenerator.new(durs_w_probs) }
   end
-  
+
   describe '#random_rhythm' do
     it 'should return durations that add to given total dur' do
       @rrgs.each do |rrg|
         [3,1,1/2.to_r,5/8.to_r,15/16.to_r].each do |total_dur|
           20.times do
             rhythm = rrg.random_rhythm(total_dur)
-            rhythm.inject(0,:+).should eq(total_dur)
+            expect(rhythm.inject(0,:+)).to eq(total_dur)
           end
         end
       end
     end
   end
-  
+
   describe '#random_dur' do
     it 'should return a random duration, according to the probabilities given at initialization' do
       @rrgs.each do |rrg|
@@ -42,7 +42,7 @@ describe RandomRhythmGenerator do
         rrg.durations.each_with_index do |dur,i|
           count = counts[dur]
           tgt_prob = rrg.probabilities[i]
-          (count / 1000.to_f).should be_within(0.05).of(tgt_prob)
+          expect((count / 1000.to_f)).to be_within(0.05).of(tgt_prob)
         end
       end
     end

data/spec/composition/model/pitch_class_spec.rb

@@ -4,48 +4,54 @@ include PitchClasses
 
 describe PitchClass do
   it 'should define the MOD constant' do
-    PitchClass.constants.should include(:MOD)
+    expect(PitchClass.constants).to include(:MOD)
   end
-  
+
   describe '.from_i' do
     it 'should return the given integer % PitchClass::MOD' do
-      PitchClass.from_i(-1).should eq(11)
-      PitchClass.from_i(12).should eq(0)
-      PitchClass.from_i(2).should eq(2)
-      PitchClass.from_i(16).should eq(4)      
+      expect(PitchClass.from_i(-1)).to eq(11)
+      expect(PitchClass.from_i(12)).to eq(0)
+      expect(PitchClass.from_i(2)).to eq(2)
+      expect(PitchClass.from_i(16)).to eq(4)
     end
   end
 
-  it 'should add the #to_pc method to the Fixnum class' do
-    5.methods.should include(:to_pc)
+  it 'should add the #to_pc method to the Integer class' do
+    expect(5.methods).to include(:to_pc)
   end
 
   it 'should add the #to_pc method to the Pitch class' do
-    Pitch.new.methods.should include(:to_pc)
+    expect(Pitch.new.methods).to include(:to_pc)
   end
 
   it 'should add the #to_pcs method to Enumerable classes, like Array' do
-    [1,2,3].methods.should include(:to_pcs)
+    expect([1,2,3].methods).to include(:to_pcs)
   end
-  
+
   describe 'Pitch#to_pc' do
     it 'should send semitone through PitchClass.from_i' do
       [ C4, D3, E5, G5,
         Pitch.new(semitone: 4),
         Pitch.new(semitone: 13),
       ].each do |pitch|
-        pitch.to_pc.should eq(PitchClass.from_i(pitch.semitone))
+        expect(pitch.to_pc).to eq(PitchClass.from_i(pitch.semitone))
       end
     end
   end
 
-  describe 'Fixnum#to_pc' do
+  describe 'Integer#to_pc' do
     it 'should pass self to PitchClass.from_i' do
       [-1,12,2,16].each do |i|
-        i.to_pc.should eq(PitchClass.from_i(i))
+        expect(i.to_pc).to eq(PitchClass.from_i(i))
       end
     end
   end
+  
+  describe 'Integer#to_pcs' do
+    it 'should pass self to PitchClass.from_i' do
+      expect([-1,12,2,16].to_pcs).to eq([-1.to_pc,12.to_pc,2.to_pc,16.to_pc])
+    end
+  end
 
   describe '.invert' do
     before :all do
@@ -62,13 +68,13 @@ describe PitchClass do
 
     it 'should produce a pitch class' do
       @cases.each do |input_pc, output_pc|
-        PitchClass.invert(input_pc).should eq(output_pc)
+        expect(PitchClass.invert(input_pc)).to eq(output_pc)
       end
     end
 
     it 'should produce a pitch class that when inverted again produces the original pitch class' do
       @cases.each do |input_pc, output_pc|
-        PitchClass.invert(output_pc).should eq(input_pc)
+        expect(PitchClass.invert(output_pc)).to eq(input_pc)
       end
     end
   end

data/spec/composition/model/pitch_classes_spec.rb

@@ -5,7 +5,7 @@ pc_syms = [:C, :Db, :D, :Eb, :E, :F, :Gb, :G, :Ab, :A, :Bb, :B]
 describe PitchClasses do
   it 'should include pitch-class constants for C, Db, D, ...' do
     pc_syms.each do |sym|
-      PitchClasses.constants.should include(sym)
+      expect(PitchClasses.constants).to include(sym)
     end
   end
 end
@@ -13,12 +13,12 @@ end
 
 describe 'PITCH_CLASSES' do
   it 'should be in the Musicality module namespace' do
-    Musicality.constants.should include(:PITCH_CLASSES)
+    expect(Musicality.constants).to include(:PITCH_CLASSES)
   end
-  
+
   it 'should have each constant value in PitchClasses' do
     PitchClasses.constants.each do |sym|
-      PITCH_CLASSES.should include(PitchClasses.const_get(sym))
+      expect(PITCH_CLASSES).to include(PitchClasses.const_get(sym))
     end
   end
-end
+end

data/spec/composition/model/rhythm_class_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe RhythmClass do
+  describe '.new' do
+    it 'should raise ArgumentError if given portions contains any zero(s)' do
+      expect { RhythmClass.new([1,0,2]) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#portions' do
+    it 'should return the same portions given initially' do
+      portions = [4,2,-2,-1]
+      rc = RhythmClass.new(portions)
+      expect(rc.portions).to eq(portions)
+    end
+  end
+
+  describe '#portions_sum' do
+    it 'should return the sum of portions using their absolute value' do
+      rc = RhythmClass.new([4,2,-2,-1])
+      expect(rc.portions_sum).to eq(9)
+    end
+  end
+
+  describe '#to_rhythm' do
+    it 'should produce the expected Rhythm object' do
+      portions = [5,1,-7,3,-1,2]
+      rhythm_class = RhythmClass.new(portions)
+      portions_sum = rhythm_class.portions_sum
+      rhythm_duration = 2
+      rhythm = rhythm_class.to_rhythm(rhythm_duration)
+
+      expect(rhythm).to be_a(Rhythm)
+      expect(rhythm.durations.size).to eq(portions.size)
+      portions.each_with_index do |portion, idx|
+        dur = rhythm.durations[idx]
+        expect(dur).to eq(rhythm_duration * Rational(portion, portions_sum))
+      end
+      expect(rhythm.durations_sum).to eq(rhythm_duration)
+    end
+  end
+end

data/spec/composition/model/rhythm_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rhythm do
+  describe '.new' do
+    it 'should raise ArgumentError if given durations contains any zero(s)' do
+      expect { Rhythm.new([1,0,2]) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#durations' do
+    it 'should return the same portions given initially' do
+      durations = [4,2,-2,-1]
+      rc = Rhythm.new(durations)
+      expect(rc.durations).to eq(durations)
+    end
+  end
+
+  describe '#durations_sum' do
+    it 'should return the sum of durations using their absolute value' do
+      rc = Rhythm.new([4,2,-2,-1])
+      expect(rc.durations_sum).to eq(9)
+    end
+  end
+
+  describe '#to_notes' do
+    it 'should produce the expected Note objects' do
+      durations = [Rational(1,2), Rational(2,1), Rational(2,3)]
+      rhythm = Rhythm.new(durations)
+      durations_sum = rhythm.durations_sum
+      pitch = Pitches::C4
+      notes = rhythm.to_notes(pitch)
+
+      expect(notes.size).to eq(durations.size)
+      notes.each do |note|
+        expect(note).to be_a(Note)
+      end
+      durations.each_with_index do |dur, idx|
+        dur2 = notes[idx].duration
+        expect(dur).to eq(dur2)
+      end
+    end
+  end
+end