musicality 0.1.0

data/spec/notation/model/pitch_spec.rb

@@ -0,0 +1,180 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Pitch do
+
+  before :each do
+    @cases = 
+    [
+      { :octave => 1, :semitone => 0, :cent => 0, :ratio => 2.0, :total_cents => 1200 },
+      { :octave => 2, :semitone => 0, :cent => 0, :ratio => 4.0, :total_cents => 2400 },
+      { :octave => 1, :semitone => 6, :cent => 0, :ratio => 2.828, :total_cents => 1800 },
+      { :octave => 2, :semitone => 6, :cent => 0, :ratio => 5.657, :total_cents => 3000 },
+      { :octave => 3, :semitone => 7, :cent => 0, :ratio => 11.986, :total_cents => 4300 },
+      { :octave => -1, :semitone => 0, :cent => 0, :ratio => 0.5, :total_cents => -1200 },
+      { :octave => -2, :semitone => 0, :cent => 0, :ratio => 0.25, :total_cents => -2400 },
+      { :octave => -2, :semitone => 7, :cent => 0, :ratio => 0.37458, :total_cents => -1700 },
+      { :octave => -1, :semitone => 9, :cent => 0, :ratio => 0.841, :total_cents => -300 },
+      { :octave => 5, :semitone => 0, :cent => 20, :ratio => 32.372, :total_cents => 6020 },
+      { :octave => 3, :semitone => 3, :cent => 95, :ratio => 10.0503, :total_cents => 3995 },
+      { :octave => -3, :semitone => 2, :cent => -20, :ratio => 0.1387, :total_cents => -3420 },
+      { :octave => -5, :semitone => -2, :cent => -77, :ratio => 0.02663, :total_cents => -6277 }
+    ]
+  end
+  
+  it "should be constructable with no parameters (no error raised)" do
+    lambda { Pitch.new }.should_not raise_error
+  end
+  
+  it "should take keyword args" do
+    obj = Pitch.new octave: 4, semitone: 3, cent: 5
+    obj.octave.should eq(4)
+    obj.semitone.should eq(3)
+    obj.cent.should eq(5)
+  end
+  
+  it "should use default octave, semitone, and cent if none is given" do
+    p = Pitch.new
+    p.ratio.should be_within(0.01).of(1.0)
+    p.total_cents.should eq(0)
+  end
+  
+  it "should use the octave and semitone given during construction" do
+    @cases.each do |case_data|
+      p = Pitch.new octave: case_data[:octave], semitone: case_data[:semitone], cent: case_data[:cent]
+      p.ratio.should be_within(0.01).of case_data[:ratio]
+      p.total_cents.should be case_data[:total_cents]
+    end
+  end
+  
+  describe '#diff' do
+    it 'should return the difference between the given pitch, in semitones' do
+      [
+	[C5,C4,12],
+	[C5,D5,-2],
+	[D5,C5,2],
+	[C5,Pitch.new(octave:5, cent:-5),5/100.0],
+	[A5,Pitch.new(octave:5, semitone: 5, cent: 22),378/100.0],
+	[A5,Pitch.new(octave:5, semitone: 11, cent: 85),-285/100.0],
+      ].each do |a,b,c|
+	a.diff(b).should eq(c)
+      end
+    end
+  end
+  
+  describe '#transpose' do
+    it 'should add the given interval to total semitones' do
+      [0,1,2,5,12,13,-1,-2,-5,-12,-13].each do |interval|
+        pitch = Eb3.transpose(interval)
+        pitch.diff(Eb3).should eq(interval)
+      end
+    end
+  end
+
+  describe '.total_semitones' do
+    it 'should convert to whole/fractional total semitones value' do
+      C4.total_semitones.should eq(48)
+      C5.total_semitones.should eq(60)
+      C4.transpose(0.1).total_semitones.should eq(48.1)
+      C5.transpose(0.19).total_semitones.should eq(60.19)
+      C5.transpose(-0.19).total_semitones.should eq(59.81)
+    end
+  end
+  
+  describe '.from_semitones' do
+    it 'should convert (rounded) fractional part to cent value' do
+      Pitch.from_semitones(4).total_cents.should eq(400)
+      Pitch.from_semitones(4.11).total_cents.should eq(411)
+      Pitch.from_semitones(57.123).total_cents.should eq(5712)
+      Pitch.from_semitones(57.125).total_cents.should eq(5713)
+    end
+  end
+  
+  describe '.from_ratio' do
+    it 'should return a Pitch with given ratio' do
+      @cases.each do |case_data|
+        p = Pitch.from_ratio case_data[:ratio]
+        p.total_cents.should eq case_data[:total_cents]
+      end
+    end
+  end
+
+  describe '.from_freq' do
+    it 'should make a pitch whose freq is approximately the given freq' do
+      [16.35, 440.0, 987.77].each do |given_freq|
+	pitch = Pitch.from_freq given_freq
+	pitch.freq.should be_within(0.01).of(given_freq)
+      end
+    end
+  end
+  
+  it "should be comparable to other pitches" do
+    p1 = Pitch.new semitone: 1
+    p2 = Pitch.new semitone: 2
+    p3 = Pitch.new semitone: 3
+
+    p1.should eq(Pitch.new semitone: 1)
+    p2.should eq(Pitch.new semitone: 2)
+    p3.should eq(Pitch.new semitone: 3)
+    
+    p1.should be < p2
+    p1.should be < p3
+    p2.should be < p3
+    p3.should be > p2
+    p3.should be > p1
+    p2.should be > p1
+  end
+  
+  it "should have freq of 440 for A4" do
+    a4 = Pitch.new octave: 4, semitone: 9
+    a4.freq.should be_within(0.01).of(440.0)
+  end
+  
+  describe '#to_yaml' do
+    it 'should produce YAML that can be loaded' do
+      p = Pitch.new(octave: 1, semitone: 2)
+      YAML.load(p.to_yaml).should eq p
+    end
+  end
+  
+  describe '#to_s' do
+    context 'on-letter semitones' do
+      it 'should return the semitone letter + octave number' do
+        { C0 => "C0", D1 => "D1", E7 => "E7",
+          F8 => "F8", G3 => "G3", A4 => "A4",
+          B5 => "B5", C2 => "C2" }.each do |p,s|
+          p.to_s.should eq s
+        end
+      end
+    end
+    
+    context 'off-letter semitones' do
+      context 'sharpit set false' do
+        it 'should return semitone letter + "b" + octave number' do
+          { Db0 => "Db0", Eb1 => "Eb1", Gb7 => "Gb7",
+            Ab4 => "Ab4", Bb1 => "Bb1" }.each do |p,s|
+            p.to_s(false).should eq s
+          end
+        end
+      end
+      
+      context 'sharpit set true' do
+        it 'should return semitone letter + "#" + octave number' do
+          { Db0 => "C#0", Eb1 => "D#1", Gb7 => "F#7",
+            Ab4 => "G#4", Bb1 => "A#1" }.each do |p,s|
+            p.to_s(true).should eq s
+          end
+        end
+      end
+    end
+    
+    context 'non-zero cent value' do
+      it 'should append +n (n = cent value)' do
+	{ C0.transpose(0.01) => "C0+1", E1.transpose(0.15) => "E1+15",
+	  G5.transpose(-0.55) => "Gb5+45"
+	}.each do |p,s|
+	  p.to_s.should eq s
+	end
+      end
+    end
+  end
+end

data/spec/notation/model/program_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Program do
+  
+  it "should assign the segments given during initialization" do
+    segments = [ 0.0...5.0, 0.0...4.0, 5.0...10.0 ]
+    program = Program.new segments
+    program.segments.should eq(segments.clone)
+  end
+  
+  describe "#include?" do
+    it "should return true for any offset which would be encountered" do
+      segments = [ 0.0...5.0, 0.0...4.0, 5.0...10.0 ]
+      program = Program.new segments
+      
+      [0.0, 4.0, 5.0, 9.999].each do |offset|
+        program.include?(offset).should be true
+      end
+    end
+
+    it "should return false for any offset which would not be encountered" do
+      segments = [ 0.0...5.0, 0.0...4.0, 5.0...10.0 ]
+      program = Program.new segments
+      
+      [-0.000001, 10.000001].each do |offset|
+        program.include?(offset).should be false
+      end
+    end
+  end
+  
+  describe '#valid?' do
+    context 'increasing, positive segments' do
+      it 'should return true' do
+        Program.new([0..2,1..2,0..4]).should be_valid
+      end
+    end
+    
+    context 'decreasing, positive segments' do
+      it 'should return false' do
+        Program.new([2..0,2..1,04..0]).should be_invalid
+      end
+    end
+
+    context 'increasing, negative segments' do
+      it 'should return false' do
+        Program.new([-1..2,-2..0,-2..2]).should be_invalid
+      end
+    end
+  end
+end

data/spec/notation/model/score_spec.rb

@@ -0,0 +1,211 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Score do
+  describe '#collated?' do
+    context 'has program with more than one segment' do
+      it 'should return false' do
+        score = Score.new(program: Program.new([0..2,0..2]))
+        score.collated?.should be false
+      end      
+    end
+    
+    context 'has program with 0 segments' do
+      it 'should return false' do
+        score = Score.new(program: Program.new([]))
+        score.collated?.should be false        
+      end
+    end
+    
+    context 'has program with 1 segment' do
+      context 'program segment starts at 0' do
+        it 'should return true' do
+          score = Score.new(program: Program.new([0..2]))
+          score.collated?.should be true
+        end
+      end
+      
+      context 'program segment does not start at 0' do
+        it 'should return false' do
+          score = Score.new(program: Program.new([1..2]))
+          score.collated?.should be false
+        end
+      end
+    end
+  end
+end
+
+describe Score::Measured do
+  describe '#initialize' do
+    it 'should use empty containers for parameters not given' do
+      s = Score::Measured.new(FOUR_FOUR,120)
+      s.parts.should be_empty
+      s.program.segments.should be_empty
+    end
+    
+    it 'should assign given parameters' do
+      m = FOUR_FOUR
+      s = Score::Measured.new(m,120)
+      s.start_meter.should eq m
+      s.start_tempo.should eq 120
+      
+      parts = { "piano (LH)" => Samples::SAMPLE_PART }
+      program = Program.new [0...0.75, 0...0.75]
+      mcs = { 1 => Change::Immediate.new(THREE_FOUR) }
+      tcs = { 1 => Change::Immediate.new(100) }
+      
+      s = Score::Measured.new(m,120,
+        parts: parts,
+        program: program,
+        meter_changes: mcs,
+        tempo_changes: tcs
+      )
+      s.parts.should eq parts
+      s.program.should eq program
+      s.meter_changes.should eq mcs
+      s.tempo_changes.should eq tcs
+    end
+  end
+  
+  describe '#valid?' do
+    {
+      'valid start tempo' => [ FOUR_FOUR, 40 ],
+      'valid tempo changes' => [ FOUR_FOUR, 30,
+        :tempo_changes => { 1 => Change::Gradual.new(40, 2), 2 => Change::Immediate.new(50) } ],
+      'valid meter changes' => [ FOUR_FOUR, 120,
+        :meter_changes => { 1 => Change::Immediate.new(TWO_FOUR) } ],
+      'valid part' => [ FOUR_FOUR, 120, :parts => { "piano" => Samples::SAMPLE_PART }],
+      'valid program' => [ FOUR_FOUR, 120, :program => Program.new([0..2,0..2]) ]
+    }.each do |context_str,args|
+      context context_str do
+        it 'should return true' do
+          Score::Measured.new(*args).should be_valid
+        end
+      end
+    end
+    
+    {
+      'start tempo object is negative' => [ FOUR_FOUR, -1],
+      'start tempo object is zero' => [ FOUR_FOUR, 0],
+      'invalid start meter' => [ Meter.new(-1,"1/4".to_r), 120],
+      'non-meter start meter' => [ 1, 120],
+      'invalid meter in change' => [ FOUR_FOUR, 120,
+        :meter_changes => { 1 => Change::Immediate.new(Meter.new(-2,"1/4".to_r)) } ],
+      'non-meter values in meter changes' => [ FOUR_FOUR, 120,
+        :meter_changes => { 1 => Change::Immediate.new(5) } ],
+      'non-immediate meter change' => [ FOUR_FOUR, 120,
+        :meter_changes => { 1 => Change::Gradual.new(TWO_FOUR,1) } ],
+      'non-integer meter change offset' => [ FOUR_FOUR, 120,
+        :meter_changes => { 1.1 => Change::Immediate.new(TWO_FOUR) } ],
+      'invalid part' => [ FOUR_FOUR, 120, :parts => { "piano" => Part.new(-0.1) }],
+      'invalid program' => [ FOUR_FOUR, 120, :program => Program.new([2..0]) ],
+    }.each do |context_str,args|
+      context context_str do
+        it 'should return false' do
+          Score::Measured.new(*args).should be_invalid
+        end
+      end      
+    end
+  end
+end
+
+describe Score::Unmeasured do
+  describe '#initialize' do
+    it 'should use empty containers for parameters not given' do
+      s = Score::Unmeasured.new(30)
+      s.parts.should be_empty
+      s.program.segments.should be_empty
+    end
+    
+    it 'should assign given parameters' do
+      s = Score::Unmeasured.new(30)
+      s.start_tempo.should eq(30)
+      
+      parts = { "piano (LH)" => Samples::SAMPLE_PART }
+      program = Program.new [0...0.75, 0...0.75]
+      tcs = { 1 => Change::Immediate.new(40) }
+      
+      s = Score::Unmeasured.new(30,
+        parts: parts,
+        program: program,
+        tempo_changes: tcs
+      )
+      s.parts.should eq parts
+      s.program.should eq program
+      s.tempo_changes.should eq tcs
+    end
+  end
+  
+  describe '#valid?' do
+    {
+      'valid start tempo' => [ 40 ],
+      'valid tempo changes' => [ 30,
+        :tempo_changes => { 1 => Change::Gradual.new(40, 2), 2 => Change::Immediate.new(50) } ],
+      'valid part' => [ 30, :parts => { "piano" => Samples::SAMPLE_PART }],
+      'valid program' => [ 30, :program => Program.new([0..2,0..2]) ]
+    }.each do |context_str,args|
+      context context_str do
+        it 'should return true' do
+          Score::Unmeasured.new(*args).should be_valid
+        end
+      end
+    end
+    
+    {
+      'start tempo valid is zero' => [ 0 ],
+      'start tempo valid is negative' => [ -1 ],
+      'tempo change value is not a valid value' => [ 30,
+        :tempo_changes => { 1 => Change::Gradual.new(-1,1) } ],
+      'invalid part' => [ 30, :parts => { "piano" => Part.new(-0.1) }],
+      'invalid program' => [ 30, :program => Program.new([2..0]) ],
+    }.each do |context_str,args|
+      context context_str do
+        it 'should return false' do
+          Score::Unmeasured.new(*args).should be_invalid
+        end
+      end 
+    end
+  end
+end
+
+describe Score::Timed do
+  describe '#initialize' do
+    it 'should use empty containers for parameters not given' do
+      s = Score::Timed.new
+      s.parts.should be_empty
+      s.program.segments.should be_empty
+    end
+    
+    it 'should assign given parameters' do
+      parts = { "piano (LH)" => Samples::SAMPLE_PART }
+      program = Program.new [0...0.75, 0...0.75]
+      
+      s = Score::Timed.new(parts: parts, program: program)
+      s.parts.should eq parts
+      s.program.should eq program
+    end
+  end
+  
+  describe '#valid?' do
+    {
+      'valid part' => [ :parts => { "piano" => Samples::SAMPLE_PART }],
+      'valid program' => [ :program => Program.new([0..2,0..2]) ]
+    }.each do |context_str,args|
+      context context_str do
+        it 'should return true' do
+          Score::Timed.new(*args).should be_valid
+        end
+      end
+    end
+    
+    {
+      'invalid part' => [ :parts => { "piano" => Part.new(-0.1) }],
+      'invalid program' => [ :program => Program.new([2..0]) ],
+    }.each do |context_str,args|
+      context context_str do
+        it 'should return false' do
+          Score::Timed.new(*args).should be_invalid
+        end
+      end 
+    end
+  end
+end

data/spec/notation/packing/change_packing_spec.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Change::Immediate do
+  describe '#pack' do
+    before :all do
+      @c = Change::Immediate.new(0.5)
+      @p = @c.pack
+    end
+    
+    it 'should return a Hash' do
+      @p.should be_a Hash
+    end
+    
+    it 'should have "type" and "value" keys' do
+      @p.should have_key("type")
+      @p.should have_key("value")
+    end
+    
+    it 'should assign "Immediate" to "type" key' do
+      @p["type"].should eq("Immediate")
+    end
+    
+    it 'should assign value to "value" key' do
+      @p["value"].should eq(@c.value)
+    end
+  end
+end
+
+describe Change::Gradual do
+  describe '#pack' do
+    context 'in general' do
+      before :all do
+        @c = Change::Gradual.new(200,2.5,3.3,4.5)
+        @p = @c.pack
+      end
+      
+      it 'should return a Hash' do
+        @p.should be_a Hash
+      end
+      
+      it 'should have "type", "value", and "impending" keys' do
+        @p.should have_key("type")
+        @p.should have_key("value")
+        @p.should have_key("impending")
+      end
+      
+      it 'should assign "Gradual" to "type" key' do
+        @p["type"].should eq("Gradual")
+      end
+      
+      it 'should assign value to "value" key' do
+        @p["value"].should eq(@c.value)
+      end
+      
+      it 'should assign impending to "impending" key' do
+        @p["impending"].should eq(@c.impending)
+      end
+    end
+    
+    context 'elapsed and remaining are 0' do
+      before :all do
+        @c = Change::Gradual.new(200,2.5)
+        @p = @c.pack
+      end
+      
+      it 'should *only* have "type", "value", and "impending" keys' do
+        @p.keys.sort.should eq(["impending","type","value"])
+      end
+    end
+
+    context 'elapsed is not 0, but remaining is 0' do
+      before :all do
+        @c = Change::Gradual.new(200,2.5,1.1)
+        @p = @c.pack
+      end
+      
+      it 'should *only* have "type", "value", "impending", and "elapsed" keys' do
+        @p.keys.sort.should eq(["elapsed","impending","type","value"])
+      end
+      
+      it 'should assign elapsed to "elapsed" key' do
+        @p["elapsed"].should eq(@c.elapsed)
+      end
+    end
+    
+    context 'elapsed and remaining are not 0' do
+      before :all do
+        @c = Change::Gradual.new(200,2.5,1.1,2.2)
+        @p = @c.pack
+      end
+      
+      it 'should *only* have "type", "value", "impending", "elapsed", and "remaining" keys' do
+        @p.keys.sort.should eq(["elapsed","impending","remaining","type","value"])
+      end
+      
+      it 'should assign remaining to "remaining" key' do
+        @p["remaining"].should eq(@c.remaining)
+      end
+    end
+  end
+end
+
+describe Change do
+  describe '.unpack' do
+    context 'given a packed immediate change' do
+      before :all do
+        @c = Change::Immediate.new(0.5)
+        @a = @c.pack
+        @c2 = Change.unpack(@a)
+      end
+      
+      it 'should return a Change::Immediate' do
+        @c2.should be_a Change::Immediate
+      end
+      
+      it 'should successfully unpack the change value' do
+        @c2.value.should eq @c.value
+      end
+      
+      it 'should successfully unpack the change duration' do
+        @c2.duration.should eq @c.duration
+      end
+    end
+    
+    context 'given a packed gradual change' do
+      before :all do
+        @c = Change::Gradual.new(0.3,1.5,1.1,0.2)
+        @a = @c.pack
+        @c2 = Change.unpack(@a)
+      end
+      
+      it 'should return a Change::Gradual' do
+        @c2.should be_a Change::Gradual
+      end
+      
+      it 'should successfully unpack the change value' do
+        @c2.value.should eq @c.value
+      end
+      
+      it 'should successfully unpack the change impending (duration)' do
+        @c2.impending.should eq @c.impending
+      end
+      
+      it 'should successfully unpack the change elapsed' do
+        @c2.elapsed.should eq @c.elapsed
+      end
+
+      it 'should successfully unpack the change remaining' do
+        @c2.remaining.should eq @c.remaining
+      end      
+    end
+  end
+end

data/spec/notation/packing/part_packing_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Part do
+  before :all do
+    @p = Part.new(
+      Dynamics::MP,
+      notes: Note.split_parse("/4Bb2 /8 /8F3= /2F3 /4Bb2 /8 /8F3= /2F3"),
+      dynamic_changes: {
+        1 => Change::Immediate.new(Dynamics::PP),
+        2 => Change::Gradual.new(Dynamics::FF, 2.0)
+      }
+    )
+    
+    @h = @p.pack
+  end
+
+  describe '#pack' do
+    it 'should produce a hash' do
+      @h.should be_a Hash
+    end
+    
+    it 'should return a hash with keys: "notes", "start_dynamic", and "dynamic_changes"' do
+      @h.keys.should include("notes")
+      @h.keys.should include("start_dynamic")
+      @h.keys.should include("dynamic_changes")
+    end
+    
+    it 'should pack notes into a string' do
+      @h['notes'].should be_a String
+    end
+    
+    it 'should pack start dynamic as plain numeric value' do
+      @h['start_dynamic'].should be_a Numeric
+    end
+    
+    it 'should pack dynamic changes as whatver type Change#pack returns' do
+      @h['dynamic_changes'].each do |offset,packed_v|
+        change_v = @p.dynamic_changes[offset]
+        t = change_v.pack.class
+        packed_v.should be_a t
+      end
+    end
+  end
+  
+  describe '.unpack' do
+    before :all do
+      @p2 = Part.unpack @h
+    end
+    
+    it 'should return a Part' do
+      @p2.should be_a Part
+    end
+    
+    it 'should successfuly unpack the notes' do
+      @p2.notes.should eq @p.notes
+    end
+    
+    it 'should successfuly unpack the start dynamic' do
+      @p2.start_dynamic.should eq @p.start_dynamic
+    end
+    
+    it 'should successfuly unpack the dynamic changes' do
+      @p2.dynamic_changes.should eq @p.dynamic_changes
+    end
+  end
+end

data/spec/notation/packing/program_packing_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Program do
+  before :all do
+    @p = Program.new([0...5,3.0...6.5,("1/2".to_r)...("3/2".to_r)])
+    @a = @p.pack
+    @p2 = Program.unpack(@a)
+  end
+
+  describe '#pack' do    
+    it 'should return an Array' do
+      @a.should be_a Array
+    end
+    
+    it 'should return an array with same size as # of segments' do
+      @a.size.should eq @p.segments.size
+    end
+    
+    it 'should return an array of strings' do
+      @a.each {|x| x.should be_a String }
+    end
+  end
+
+  describe '#unpack' do
+    it 'should return a Program' do
+      @p2.should be_a Program
+    end
+    
+    it 'should successfully unpack program segments' do
+      @p2.segments.should eq @p.segments
+    end
+  end
+end