musicality 0.1.0

data/spec/notation/parsing/note_node_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+NOTE_PARSER = Parsing::NoteParser.new
+
+describe Parsing::NoteNode do
+  context 'rest note' do  
+    {
+      '/2' => Note.new(Rational(1,2)),
+      '4/2' => Note.new(Rational(4,2)),
+      '28' => Note.new(Rational(28,1)),
+      '56/33' => Note.new(Rational(56,33)),
+    }.each do |str,tgt|
+      res = NOTE_PARSER.parse(str)
+      context str do
+        it 'should parse as NoteNode' do
+          res.should be_a Parsing::NoteNode
+        end
+  
+        describe '#to_note' do
+          n = res.to_note
+          it 'should produce a Note' do
+            n.should be_a Note
+          end
+          
+          it 'should produce value matching input str' do
+            n.should eq tgt
+          end
+        end
+      end
+    end
+  end
+
+  context 'monophonic note' do
+    {
+      '/2=C2=C2' => Note.new(Rational(1,2),[C2],articulation:SLUR, links:{C2=>Link::Slur.new(C2)}),
+      '4/2.D#6' => Note.new(Rational(4,2),[Eb6],articulation:STACCATO),
+      '28%Eb7!' => Note.new(Rational(28,1),[Eb7],articulation:PORTATO, accented: true),
+      "56/33'B1" => Note.new(Rational(56,33),[B1],articulation:STACCATISSIMO),
+    }.each do |str,tgt|
+      res = NOTE_PARSER.parse(str)
+      
+      context str do
+        it 'should parse as MonophonicNoteNode' do
+          res.should be_a Parsing::NoteNode
+        end
+  
+        describe '#to_note' do
+          n = res.to_note
+          it 'should produce a Note' do
+            n.should be_a Note
+          end
+          
+          it 'should produce value matching input str' do
+            n.should eq tgt
+          end
+        end
+      end
+    end
+  end
+
+  context 'polyphonic note' do
+    {
+      '/2C2,D2,E2|F2' => Note.new(Rational(1,2),[C2,D2,E2],links:{E2=>Link::Legato.new(F2)}),
+      '4/2.D#6,G4' => Note.new(Rational(4,2),[Eb6,G4], articulation:STACCATO),
+      '28_Eb7,D7,G7' => Note.new(Rational(28,1),[Eb7,D7,G7],articulation:TENUTO),
+      '56/33B1,B2,B3,B4,B5!' => Note.new(Rational(56,33),[B1,B2,B3,B4,B5], accented: true),
+    }.each do |str,tgt|
+      res = NOTE_PARSER.parse(str)
+      context str do
+        it 'should parse as PolyphonicNoteNode' do
+          res.should be_a Parsing::NoteNode
+        end
+  
+        describe '#to_note' do
+          n = res.to_note
+          it 'should produce a Note' do
+            n.should be_a Note
+          end
+          
+          it 'should produce value matching input str' do
+            n.should eq tgt
+          end
+        end
+      end
+    end
+  end
+end

data/spec/notation/parsing/note_parsing_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Parsing::NoteParser do
+  before :all do
+    @parser = Parsing::NoteParser.new
+  end
+  
+   valid_cases = {
+    'duration only' => ['1/4','/2','1','55/33'],
+    'duration + accent' => ['1/4!','/2!'],
+    'duration + articulation' => ['1/4.','/2%','2/3='],
+    'duration + articulation + accent' => ['1/4.!','/2%!','2/3=!'],
+    'single pitch' => ['/4C2','5/3Db3','/33E#8'],
+    'multiple pitches' => ['/4C2,C3,c5','5/3Db3,Bb2,E5','/33E#8,F1,B9'],
+    'with articulation' => ['/4.C2',"5/3'Db3,Bb2,E5",'/33=F3','5|B2','/2_D3,F4'],
+    'with accent' => ['/4C2!','3/2Db3,Bb4!'],
+    'with links' => ['/2C2=','/2C2=D2','/4D4|E4,G4~A5'],
+    'with single pitch + articulation + link + accent' => [
+      '3/4.D2=!','5/8=F2=!','/8Db4|Db5!','/3_G4~B4!'],
+    'with multiple pitches + articulation + links + accent' => [
+      '5/4.D2=,G4|A4,C3~D3!','5/8|F2=D4,B4/A4!'],
+  }
+  invalid_cases = {
+    'single pitch' => ['5/3Hb|3','/33E|2'],
+    'multiple pitches' => ['5/3Db3,Bb|1,E5','/33H8,F1,B9'],
+    'with articulation' => ['/4[C2',"5/3>Db3"],
+    'with accent' => ['/4C2['],
+    'with links' => ['/2C2)'],
+  }
+  
+  valid_cases.each do |descr, strs|
+    context(descr + ' (valid)') do
+      it 'should parse' do
+        strs.each {|s| @parser.should parse(s) }
+      end
+    end
+  end
+
+  invalid_cases.each do |descr, strs|
+    context(descr + ' (invalid)') do
+      it 'should not parse' do
+        strs.each {|s| @parser.should_not parse(s) }
+      end
+    end
+  end
+end

data/spec/notation/parsing/numbers/nonnegative_float_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Parsing::NonnegativeFloatParser do
+  parser = Parsing::NonnegativeFloatParser .new
+
+  ["0.0","0e1","2e2","1.0","0.50","05.003e-10","1.555e+2","3.443214","0.001","0000.0030000"].each do |str|
+    res = parser.parse(str)
+    f = str.to_f
+    
+    it "should parse '#{str}'" do
+      res.should_not be nil
+    end
+
+    it 'should return node that is convertible to float using #to_f method' do
+      res.to_f.should eq(f)
+    end
+    
+    it 'should return node that is convertible to float using #to_num method' do
+      res.to_num.should eq(f)
+    end
+  end
+  
+  ["-1.0","-0e1"].each do |str|
+    it "should not parse '#{str}'" do
+      parser.should_not parse(str)
+    end    
+  end
+end

data/spec/notation/parsing/numbers/nonnegative_integer_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Parsing::NonnegativeIntegerParser do
+  parser = Parsing::NonnegativeIntegerParser.new
+
+  ["1","50","05","502530","0"].each do |str|
+    it "should parse '#{str}'" do
+      parser.parse(str).should_not be nil
+    end
+  end
+end

data/spec/notation/parsing/numbers/nonnegative_rational_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Parsing::NonnegativeRationalParser do
+  parser = Parsing::NonnegativeRationalParser.new
+
+  ["1/2","0/50","05/003","502530/1","0/1"].each do |str|
+    it "should parse '#{str}'" do
+      parser.parse(str).should_not be nil
+    end
+  end
+end

data/spec/notation/parsing/numbers/positive_float_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Parsing::PositiveFloatParser do
+  parser = Parsing::PositiveFloatParser.new
+
+  ["2e2","1.0","0.50","05.003e-10","1.555e+2","3.443214","0.001","0000.0030000"].each do |str|
+    res = parser.parse(str)
+    f = str.to_f
+    
+    it "should parse '#{str}'" do
+      res.should_not be nil
+    end
+
+    it 'should return node that is convertible to float using #to_f method' do
+      res.to_f.should eq(f)
+    end
+    
+    it 'should return node that is convertible to float using #to_num method' do
+      res.to_num.should eq(f)
+    end
+  end
+  
+  ["-2.0","-1.55e-2","0.0","0e1"].each do |str|
+    it "should not parse '#{str}'" do
+      parser.should_not parse(str)
+    end    
+  end
+end

data/spec/notation/parsing/numbers/positive_integer_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Parsing::PositiveIntegerParser do
+  parser = Parsing::PositiveIntegerParser.new
+
+  ["1","50","05","502530"].each do |str|
+    res = parser.parse(str)
+    i = str.to_i
+    
+    it "should parse '#{str}'" do
+      res.should_not be nil
+    end
+
+    it 'should return node that is convertible to integer using #to_i method' do
+      res.to_i.should eq(i)
+    end
+    
+    it 'should return node that is convertible to integer using #to_num method' do
+      res.to_num.should eq(i)
+    end
+  end
+
+  ["0"].each do |str|
+    it "should not parse '#{str}'" do
+      parser.should_not parse(str)
+    end
+  end
+end

data/spec/notation/parsing/numbers/positive_rational_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Parsing::PositiveRationalParser do
+  parser = Parsing::PositiveRationalParser.new
+
+  ["1/2","50/50","050/003","502530/1","01/1"].each do |str|
+    res = parser.parse(str)
+    r = str.to_r
+    
+    it "should parse '#{str}'" do
+      res.should_not be nil
+    end
+
+    it 'should return node that is convertible to rational using #to_r method' do
+      res.to_r.should eq(r)
+    end
+    
+    it 'should return node that is convertible to rational using #to_num method' do
+      res.to_num.should eq(r)
+    end
+  end
+
+  ["0/0","0/10","0000/1"].each do |str|
+    it "should not parse '#{str}'" do
+      parser.should_not parse(str)
+    end
+  end
+end

data/spec/notation/parsing/pitch_node_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Parsing::PitchNode do
+  parser = Parsing::PitchParser.new
+  
+  {
+    'C4' => C4,
+    'Db2' => Db2,
+    'C#2' => Db2,
+    'Db2' => Db2,
+    'F7' => F7,
+    'B1' => B1,
+    "Bb22" => Pitch.new(octave: 22, semitone: 10),
+    "G2235" => Pitch.new(octave: 2235, semitone: 7),
+    "G2+11" => G2.transpose(0.11),
+    "G2-11" => G2.transpose(-0.11),
+    "A2-11301" => A2.transpose(-113.01),
+    "B5+881" => B5.transpose(8.81),
+  }.each do |str,tgt|
+    res = parser.parse(str)
+    context str do
+      it 'should parse as PitchNode' do
+        res.should be_a Parsing::PitchNode
+      end
+      
+      describe '#to_pitch' do
+        p = res.to_pitch
+        it 'should produce a Pitch object' do
+          p.should be_a Pitch
+        end
+        
+        it 'should produce pitch matching input str' do
+          p.should eq tgt
+        end
+      end
+    end
+  end  
+end

data/spec/notation/parsing/pitch_parsing_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Parsing::PitchParser do
+  before :all do
+    @parser = Parsing::PitchParser.new
+  end
+  
+  ["C4","C#9","Ab0","G#2","E2+22","Cb5-99","G200","Bb9951+3920"
+  ].each do |str|
+    it "should parse #{str}" do
+      @parser.should parse(str)
+    end
+  end
+end

data/spec/notation/parsing/segment_parsing_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Parsing::SegmentParser do
+  parser = Parsing::SegmentParser.new
+
+  cases = {
+    "ints" => ["0...4",0...4],
+    "plain floats" => ["0.0..4.0",0.0...4.0],
+    "sci floats" => ["1.3e-10...5",1.3e-10...5],
+    "int/float" => ["45..46.5",45...46.5],
+    "float/int" => ["4.5...5",4.5...5],
+    "rationals" => ["2/3..3/2",Rational(2,3)...Rational(3,2)],
+    "float/rational" => ["3.5..10/6",3.5...Rational(10,6)]
+  }.each do |descr,str_tgt|
+    context descr do
+      str,tgt = str_tgt
+      res = parser.parse(str)
+      it 'should parse' do
+        res.should_not be nil
+      end
+      
+      it 'should return node that converts to exclusive range via #to_range' do
+        res.to_range.should eq tgt
+      end
+    end
+  end
+end

data/spec/notation/util/value_computer_spec.rb

@@ -0,0 +1,146 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe ValueComputer do
+  describe '#value_at' do
+    before :all do
+      @value_change1 = Change::Immediate.new(0.6)
+      @value_change2 = Change::Gradual.new(0.6, 1.0)
+    end
+    
+    context "constant value" do
+      before :each do
+        @comp = ValueComputer.new 0.5
+      end
+      
+      it "should always return default value if no changes are given" do
+        [ValueComputer.domain_min, -1000, 0, 1, 5, 100, 10000, ValueComputer.domain_max].each do |offset|
+          @comp.value_at(offset).should eq(0.5)
+        end
+      end
+    end
+    
+    context "one change, no transition" do
+      before :each do
+        @comp = ValueComputer.new 0.5, 1.0 => @value_change1
+      end
+      
+      it "should be the default value just before the first change" do
+        @comp.value_at(0.999).should eq(0.5)
+      end
+          
+      it "should transition to the second value immediately" do
+        @comp.value_at(1.0).should eq(0.6)
+      end
+
+      it "should be the first value for all time before" do
+        @comp.value_at(ValueComputer.domain_min).should eq(0.5)
+      end
+      
+      it "should be at the second value for all time after" do
+        @comp.value_at(ValueComputer.domain_max).should eq(0.6)
+      end
+    end
+    
+    context "one change, linear transition" do
+      before :each do
+        @comp = ValueComputer.new 0.2, 1.0 => @value_change2
+      end
+      
+      it "should be the first (starting) value just before the second value" do
+        @comp.value_at(0.999).should eq(0.2)
+      end
+          
+      it "should be the first (starting) value exactly at the second value" do
+        @comp.value_at(1.0).should eq(0.2)
+      end
+    
+      it "should be 1/4 to the second value after 1/4 transition duration has elapsed" do
+        @comp.value_at(Rational(5,4).to_f).should eq(0.3)
+      end
+    
+      it "should be 1/2 to the second value after 1/2 transition duration has elapsed" do
+        @comp.value_at(Rational(6,4).to_f).should eq(0.4)
+      end
+    
+      it "should be 3/4 to the second value after 3/4 transition duration has elapsed" do
+        @comp.value_at(Rational(7,4).to_f).should eq(0.5)
+      end
+    
+      it "should be at the second value after transition duration has elapsed" do
+        @comp.value_at(Rational(8,4).to_f).should eq(0.6)
+      end
+    end
+
+  #  context "one change, sigmoid transition" do
+  #    before :all do
+  #      @cases = [
+  #        { :start_value => 0, :end_value => 1, :offset => 0, :duration => 1.0, :abruptness => 0.75 },
+  #        { :start_value => 0.25, :end_value => 0.75, :offset => 1.0, :duration => 2.0, :abruptness => 0.75 },
+  #        { :start_value => -1.0, :end_value => 5.5, :offset => 2.4, :duration => 20, :abruptness => 0.75 },
+  #        { :start_value => 10, :end_value => 100, :offset => 20, :duration => 4, :abruptness => 0.75 },
+  #      ]
+  #  
+  #      @computers = {}
+  #      @cases.each do |case_hash|
+  #        start_value = case_hash[:start_value]
+  #        offset = case_hash[:offset]
+  #        end_value = case_hash[:end_value]
+  #        duration = case_hash[:duration]
+  #        #abruptness = case_hash[:abruptness]
+  #        
+  #        change = Change::Gradual.new(end_value, duration)
+  #        @computers[case_hash] = ValueComputer.new start_value, offset => change
+  #        # @computers[case_hash].plot_range(offset..(offset + duration), 0.01)
+  #      end
+  #    end
+  #  
+  #    it "should be the first (starting) value just before the value change offset" do
+  #      @computers.each do |case_hash, comp|
+  #        comp.value_at(case_hash[:offset] - 0.0001).should eq(case_hash[:start_value])
+  #      end
+  #    end
+  #        
+  #    it "should be very nearly the first (starting) value exactly at the value change offset" do
+  #      @computers.each do |case_hash, comp|
+  #        comp.value_at(case_hash[:offset]).should be_within(0.0001).of(case_hash[:start_value])
+  #      end
+  #    end
+  #  
+  #    it "should be within 1% of start/end difference away from the start value after 1/4 transition duration has elapsed" do
+  #      @computers.each do |case_hash, comp|
+  #        test_offset = case_hash[:offset] + (case_hash[:duration] * 0.25)
+  #        start_value = case_hash[:start_value]
+  #        end_value = case_hash[:end_value]
+  #        tolerance = 0.01 * (end_value - start_value)
+  #        comp.value_at(test_offset).should be_within(tolerance).of(start_value)
+  #      end
+  #    end
+  #  
+  #    it "should be half way to the end value after half way through transition" do
+  #      @computers.each do |case_hash, comp|
+  #        test_offset = case_hash[:offset] + (case_hash[:duration] * 0.5)
+  #        start_value = case_hash[:start_value]
+  #        expected_value = start_value + (case_hash[:end_value] - start_value) * 0.5
+  #        comp.value_at(test_offset).should be_within(0.0001).of(expected_value)
+  #      end
+  #    end
+  #  
+  #    it "should be within 1% of start/end difference away from the end value after 3/4 transition duration has elapsed" do
+  #      @computers.each do |case_hash, comp|
+  #        test_offset = case_hash[:offset] + (case_hash[:duration] * 0.75)
+  #        start_value = case_hash[:start_value]
+  #        end_value = case_hash[:end_value]
+  #        tolerance = 0.01 * (end_value - start_value)
+  #        comp.value_at(test_offset).should be_within(tolerance).of(end_value)
+  #      end
+  #    end
+  #  
+  #    it "should be at the second value after transition duration has elapsed" do
+  #      @computers.each do |case_hash, comp|
+  #        comp.value_at(case_hash[:offset] + case_hash[:duration]).should eq(case_hash[:end_value])
+  #      end
+  #    end
+  #  end
+  end
+end
+

data/spec/performance/conversion/glissando_converter_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe GlissandoConverter do
+  describe '.glissando_pitches' do
+    context 'start pitch <= target pitch' do
+      [
+        [F3,B3],
+        [C4,Gb5],
+        [D2,C5],
+        [F2,F2],
+        [C4.transpose(0.5),D4],
+        [C4.transpose(0.5),D4.transpose(0.5)],
+        [C4.transpose(0.01),F5],
+        [C4.transpose(-0.01),F5.transpose(-0.01)],
+      ].each do |start,finish|
+        context "start at #{start.to_s}, target #{finish.to_s}" do
+          pitches = GlissandoConverter.glissando_pitches(start,finish)
+          
+          it 'should begin with start pitch' do
+            pitches.first.should eq(start)
+          end
+          
+          it 'should move up to next whole (zero-cent) pitches' do
+            (1...pitches.size).each do |i|
+              pitches[i].cent.should eq(0)
+              pitches[i].diff(pitches[i-1]).should be <= 1
+            end
+          end
+          
+          it 'should end on the whole (zero-cent) pitch below target pitch' do
+            pitches.last.cent.should eq(0)
+            diff = finish.total_cents - pitches.last.total_cents
+            diff.should be <= 100
+          end
+        end
+      end
+    end
+    
+    context 'start pitch > target pitch' do
+      [
+        [B3,F3],
+        [Gb5,C4],
+        [C5,D2],
+        [D4,C4.transpose(0.5)],
+        [D4.transpose(0.5),C4.transpose(0.5)],
+        [F5,C4.transpose(0.01)],
+        [F5.transpose(-0.01),C4.transpose(-0.01)],
+      ].each do |start,finish|
+        context "start at #{start.to_s}, target #{finish.to_s}" do
+          pitches = GlissandoConverter.glissando_pitches(start,finish)
+          
+          it 'should move down to next whole (zero-cent) pitches' do
+            (1...pitches.size).each do |i|
+              pitches[i].cent.should eq(0)
+              pitches[i-1].diff(pitches[i]).should be <= 1
+            end
+          end
+          
+          it 'should end on the whole (zero-cent) pitch above target pitch' do
+            pitches.last.cent.should eq(0)
+            diff = pitches.last.total_cents - finish.total_cents
+            diff.should be <= 100
+          end
+
+        end
+      end
+    end
+  end
+  
+  describe '.glissando_elements' do
+    before :all do
+      @dur = Rational(3,2)
+      @acc = false
+      @els = GlissandoConverter.glissando_elements(C4,A4,@dur,@acc)
+    end
+    
+    it 'should return an array of LegatoElement objects' do
+      @els.each {|el| el.should be_a LegatoElement }
+    end
+    
+    it 'should split up duration among elements' do
+      sum = @els.map {|el| el.duration }.inject(0,:+)
+      sum.should eq(@dur)
+    end
+    
+    it 'should set accented as given' do
+      els = GlissandoConverter.glissando_elements(C4,A4,1,false)
+      els.each {|el| el.accented.should eq(false) }
+      els = GlissandoConverter.glissando_elements(C4,A4,1,true)
+      els.each {|el| el.accented.should eq(true) }
+    end
+  end
+end