musicality 0.1.0

data/spec/notation/packing/score_packing_spec.rb

@@ -0,0 +1,301 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+measured_score = Score::Measured.new(FOUR_FOUR,120) do |s|
+  s.program = Program.new([0...2, 0...2,2...4,0...2])
+  s.parts["lead"] = Part.new(Dynamics::MF) do |p|
+    riff = "/6Bb3 /4 /12Db4= /6Db4= /36Db4 /36Eb4 /36Db4 /6Ab3 /12Db4 \
+            /6Bb3 /4 /12Db4= /4Db4=                      /8=Db4 /8C4".to_notes
+    p.notes = riff + riff.map {|n| n.transpose(2) }
+  end
+  
+  s.parts["bass"] = Part.new(Dynamics::MP) do |p|
+    riff = "/6Bb2 /4 /3Ab2 /6F2 /12Ab2 \
+            /6Bb2 /4 /3Ab2 /4Ab2".to_notes
+    p.notes = riff + riff.map {|n| n.transpose(2) }
+  end
+end
+
+unmeasured_score = Score::Unmeasured.new(30) do |s|
+  s.program = measured_score.program
+  s.parts = measured_score.parts
+end
+
+timed_score = Score::Timed.new do |s|
+  s.program = measured_score.program
+  s.parts = measured_score.parts
+end
+
+describe Score::Measured do
+  before :all do
+    @score = measured_score
+    @h = @score.pack
+  end
+  
+  describe '#pack' do
+    it 'should return a hash' do
+      @h.should be_a Hash
+    end
+    
+    it 'should return a hash with keys: "type","parts", "start_meter", ...' do
+      ["type","parts","start_tempo","tempo_changes","program","start_meter","meter_changes"].each do |key|
+        @h.should have_key(key)
+      end
+    end
+    
+    it 'should set "type" key to "Measured"' do
+      @h["type"].should eq("Measured")
+    end
+    
+    it 'should pack start meter as a string' do
+      @h['start_meter'].should be_a String
+    end
+    
+    it 'should pack meter changes as whatver type Change#pack returns' do
+      @h['meter_changes'].each do |offset,packed_v|
+        change_v = @score.meter_changes[offset]
+        t = change_v.pack.class
+        packed_v.should be_a t
+      end
+    end
+
+    it 'should pack meter change values as strings' do
+      @h['meter_changes'].each do |offset,packed_v|
+        packed_v[0].should be_a String
+      end
+    end
+    
+    it 'should pack start tempo as numeric' do
+      @h['start_tempo'].should be_a Numeric
+    end
+    
+    it 'should pack tempo changes as whatver type Change#pack returns' do
+      @h['tempo_changes'].each do |offset,packed_v|
+        change_v = @score.tempo_changes[offset]
+        t = change_v.pack.class
+        packed_v.should be_a t
+      end
+    end
+    
+    it 'should pack tempo change values as numerics' do
+      @h['tempo_changes'].each do |offset,packed_v|
+        packed_v[0].should be_a Numeric
+      end
+    end
+    
+    it 'should pack program as whatever type Program#pack returns' do
+      t = @score.program.pack.class
+      @h['program'].should be_a t
+    end
+    
+    it 'should pack program segments as strings' do
+      @h['program'].each {|x| x.should be_a String }
+    end
+
+    it 'should pack parts as hash' do
+      @h['parts'].should be_a Hash
+    end
+    
+    it 'should pack parts as whatever Part#pack returns' do
+      @score.parts.each do |name,part|
+        packing = part.pack
+        @h['parts'][name].should eq packing
+      end
+    end
+  end
+  
+  describe '.unpack' do
+    before :all do
+      @score2 = Score::Measured.unpack @h
+    end
+    
+    it 'should return a Score::Measured' do
+      @score2.should be_a Score::Measured
+    end
+    
+    it 'should successfuly unpack the parts' do
+      @score2.parts.should eq @score.parts
+    end
+    
+    it 'should successfuly unpack the start meter' do
+      @score2.start_meter.should eq @score.start_meter
+    end
+
+    it 'should successfuly unpack the start tempo' do
+      @score2.start_tempo.should eq @score.start_tempo
+    end
+
+    it 'should successfuly unpack the meter changes' do
+      @score2.meter_changes.should eq @score.meter_changes
+    end
+
+    it 'should successfuly unpack the tempo changes' do
+      @score2.tempo_changes.should eq @score.tempo_changes
+    end
+
+    it 'should successfuly unpack the program' do
+      @score2.program.should eq @score.program
+    end
+  end
+end
+
+describe Score::Unmeasured do
+  before :all do
+    @score = unmeasured_score
+    @h = @score.pack
+  end
+  
+  describe '#pack' do
+    it 'should return a hash' do
+      @h.should be_a Hash
+    end
+    
+    it 'should return a hash with keys: "type","parts", "program", ...' do
+      ["type","parts","start_tempo","tempo_changes","program"].each do |key|
+        @h.should have_key(key)
+      end
+    end
+    
+    it 'should set "type" key to "Unmeasured"' do
+      @h["type"].should eq("Unmeasured")
+    end
+    
+    it 'should pack start tempo as numeric' do
+      @h['start_tempo'].should be_a Numeric
+    end
+    
+    it 'should pack tempo changes as whatver type Change#pack returns' do
+      @h['tempo_changes'].each do |offset,packed_v|
+        change_v = @score.tempo_changes[offset]
+        t = change_v.pack.class
+        packed_v.should be_a t
+      end
+    end
+    
+    it 'should pack tempo change values as numerics' do
+      @h['tempo_changes'].each do |offset,packed_v|
+        packed_v[0].should be_a Numeric
+      end
+    end
+
+    it 'should pack program as whatever type Program#pack returns' do
+      t = @score.program.pack.class
+      @h['program'].should be_a t
+    end
+    
+    it 'should pack program segments as strings' do
+      @h['program'].each {|x| x.should be_a String }
+    end
+
+    it 'should pack parts as hash' do
+      @h['parts'].should be_a Hash
+    end
+    
+    it 'should pack parts as whatever Part#pack returns' do
+      @score.parts.each do |name,part|
+        packing = part.pack
+        @h['parts'][name].should eq packing
+      end
+    end
+  end
+  
+  describe '.unpack' do
+    before :all do
+      @score2 = Score::Unmeasured.unpack @h
+    end
+    
+    it 'should return a Score::Unmeasured' do
+      @score2.should be_a Score::Unmeasured
+    end
+    
+    it 'should successfuly unpack the parts' do
+      @score2.parts.should eq @score.parts
+    end
+    
+    it 'should successfuly unpack the start tempo' do
+      @score2.start_tempo.should eq @score.start_tempo
+    end
+
+    it 'should successfuly unpack the tempo changes' do
+      @score2.tempo_changes.should eq @score.tempo_changes
+    end
+
+    it 'should successfuly unpack the program' do
+      @score2.program.should eq @score.program
+    end
+  end
+end
+
+describe Score::Timed do
+  before :all do
+    @score = timed_score
+    @h = @score.pack
+  end
+  
+  describe '#pack' do
+    it 'should return a hash' do
+      @h.should be_a Hash
+    end
+    
+    it 'should return a hash with keys: "type","parts", and "program"' do
+      ["type","parts","program"].each do |key|
+        @h.should have_key(key)
+      end
+    end
+    
+    it 'should set "type" key to "Timed"' do
+      @h["type"].should eq("Timed")
+    end
+    
+    it 'should pack program as whatever type Program#pack returns' do
+      t = @score.program.pack.class
+      @h['program'].should be_a t
+    end
+    
+    it 'should pack program segments as strings' do
+      @h['program'].each {|x| x.should be_a String }
+    end
+
+    it 'should pack parts as hash' do
+      @h['parts'].should be_a Hash
+    end
+    
+    it 'should pack parts as whatever Part#pack returns' do
+      @score.parts.each do |name,part|
+        packing = part.pack
+        @h['parts'][name].should eq packing
+      end
+    end
+  end
+  
+  describe '.unpack' do
+    before :all do
+      @score2 = Score::Timed.unpack @h
+    end
+    
+    it 'should return a Score::Timed' do
+      @score2.should be_a Score::Timed
+    end
+    
+    it 'should successfuly unpack the parts' do
+      @score2.parts.should eq @score.parts
+    end
+    
+    it 'should successfuly unpack the program' do
+      @score2.program.should eq @score.program
+    end
+  end
+end
+
+describe Score do
+  describe '.unpack' do
+    [ timed_score, unmeasured_score, measured_score ].each do |score|
+      context "given packing from a #{score.class} object" do
+        it "should return a #{score.class} object equal to original" do
+          score2 = Score.unpack(score.pack)
+          score2.should be_a score.class
+          score2.should eq(score)
+        end
+      end
+    end
+  end
+end

data/spec/notation/parsing/articulation_parsing_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Parsing::ArticulationParser do
+  parser = Parsing::ArticulationParser.new
+  
+  {
+    '=' => SLUR,
+    '|' => LEGATO,
+    '_' => TENUTO,
+    '%' => PORTATO,
+    '.' => STACCATO,
+    "'" => STACCATISSIMO
+  }.each do |str,art|
+    res = parser.parse(str)
+    it "should parse '#{str}'" do
+      res.should_not be nil
+    end
+    
+    it 'should return a node to responds to :to_articulation correctly' do
+      res.to_articulation.should eq art
+    end
+  end
+end

data/spec/notation/parsing/convenience_methods_spec.rb

@@ -0,0 +1,99 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+class_cases = { Duration => {
+  '/2' => "1/2".to_r,
+  '5/29' => "5/29".to_r,
+  '200/' => "200/1".to_r,
+  '66' => "66/1".to_r
+  },
+  Note => {
+    '/2' => Note::half,
+    '99/10C2' => Note.new('99/10'.to_r, [C2]),
+    '5/2.Db4,Eb5' => Note.new('5/2'.to_r, [Db4,Eb5], articulation:STACCATO) 
+  },
+  Pitch => {
+    'C2' => C2,
+    'Db4' => Db4,
+    'A#9' => Bb9
+  },
+  Meter => {
+    '2/2' => Meter.new(2,"1/2".to_r),
+    "4/4" => Meter.new(4,"1/4".to_r),
+    "6/8" => Meter.new(6,"1/8".to_r),
+    "12/3" => Meter.new(12,"1/3".to_r),
+    "133/55" => Meter.new(133,"1/55".to_r),
+  },
+  Segment => {
+  }
+}
+
+class_cases.each do |klass,cases|
+  describe("#{klass}.parse") do
+    it "should produce a single #{klass}" do
+      cases.each do |str,tgt|
+        klass.parse(str).should eq(tgt)
+      end
+    end
+  end
+  
+  describe("#{klass}.split_parse") do
+    context 'joined with whitespace, using default pattern' do
+      it "should produce multiple of #{klass}" do
+        str = cases.keys.join(" ")
+        klass.split_parse(str).should eq(cases.values)
+      end
+    end
+    
+    context 'joined by custom separator, using matching pattern' do
+      it "should raise produce multiple of #{klass}" do
+        str = cases.keys.join(";")
+        klass.split_parse(str,";").should eq(cases.values)
+      end
+    end
+  end
+end
+
+{
+  Duration => [:to_d, :to_dur, :to_duration],
+  Pitch => [:to_p, :to_pitch],
+  Note => [:to_n, :to_note],
+  Meter => [:to_meter],
+}.each do |klass,str_parse_methods|
+  describe 'String' do
+    str_parse_methods.each do |method|
+      describe "\##{method}" do
+        it "should return a #{klass}" do
+          class_cases[klass].each do |str,tgt|
+            str.send(method).should eq(tgt)
+          end
+        end
+      end
+    end
+  end
+end
+
+{
+  Duration => [:to_ds, :to_durs, :to_durations],
+  Pitch => [:to_ps, :to_pitches],
+  Note => [:to_ns, :to_notes],
+}.each do |klass,str_parse_methods|
+  describe 'String' do
+    str_parse_methods.each do |method|
+      describe "\##{method}" do
+        context 'joined with whitespace' do
+          it "should return multiple of #{klass}" do
+            str = class_cases[klass].keys.join(" ")
+            str.send(method).should eq(class_cases[klass].values)
+          end
+        end
+        
+        context 'joined by custom separator, using matching pattern' do
+          it "should raise produce multiple of #{klass}" do
+            str = class_cases[klass].keys.join(";")
+            str.send(method,";").should eq(class_cases[klass].values)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/notation/parsing/duration_nodes_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Parsing::NumDenNode do
+  dur_parser = Parsing::DurationParser.new
+  
+  {
+    '1/2' => Rational(1,2),
+    '5/100' => Rational(5,100),
+    '007/777' => Rational(7,777)
+  }.each do |str,tgt|
+    res = dur_parser.parse(str)
+    context str do
+      it 'should parse as NumDenNode' do
+        res.should be_a Parsing::NumDenNode
+      end
+
+      describe '#to_r' do
+        r = res.to_r
+        it 'should produce a Rational' do
+          r.should be_a Rational
+        end
+        
+        it 'should produce value matching input str' do
+          r.should eq tgt
+        end
+      end
+    end
+  end
+end
+
+describe Parsing::NumOnlyNode do
+  dur_parser = Parsing::DurationParser.new
+    {
+    '1/' => Rational(1,1),
+    '5' => Rational(5,1),
+    '007/' => Rational(7,1)
+  }.each do |str,tgt|
+    res = dur_parser.parse(str)
+    context str do
+      it 'should parse as NumOnlyNode' do
+        res.should be_a Parsing::NumOnlyNode
+      end
+
+      describe '#to_r' do
+        r = res.to_r
+        it 'should produce a Rational' do
+          r.should be_a Rational
+        end
+        
+        it 'should produce value matching input str' do
+          r.should eq tgt
+        end
+      end
+    end
+  end
+end
+
+describe Parsing::DenOnlyNode do
+  dur_parser = Parsing::DurationParser.new
+  {
+    '/2' => Rational(1,2),
+    '/100' => Rational(1,100),
+    '/777' => Rational(1,777)
+  }.each do |str,tgt|
+    res = dur_parser.parse(str)
+    context str do
+      it 'should parse as DenOnlyNode' do
+        res.should be_a Parsing::DenOnlyNode
+      end
+
+      describe '#to_r' do
+        r = res.to_r
+        it 'should produce a Rational' do
+          r.should be_a Rational
+        end
+        
+        it 'should produce value matching input str' do
+          r.should eq tgt
+        end
+      end
+    end
+  end
+end

data/spec/notation/parsing/duration_parsing_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Parsing::DurationParser do
+  dur_parser = Parsing::DurationParser.new
+  before :all do
+    @valid = {
+      :numbers => [1,5,50,3999,01,0010,0000005050],
+    }
+    
+    @invalid = {
+      :numbers => [0,00],
+    }    
+  end
+  
+  context 'valid (non-zero) numerator and denominator' do
+    ["n","n/","n/d","/d"].each do |expr|
+      it "should parse durations of the form #{expr}" do
+        @valid[:numbers].each do |n|
+          @valid[:numbers].each do |d|
+            str = expr.gsub('n',"#{n}")
+            str = str.gsub('d',"#{d}")
+            dur_parser.parse(str).should_not be nil
+          end
+        end
+      end
+    end
+  end
+
+  context 'invalid (zero) numerator and valid denominator' do
+    ["n","n/","n/d"].each do |expr|
+      it "should parse durations of the form #{expr}" do
+        @invalid[:numbers].each do |n|
+          @valid[:numbers].each do |d|
+            str = expr.gsub('n',"#{n}")
+            str = str.gsub('d',"#{d}")
+            dur_parser.parse(str).should be nil
+          end
+        end
+      end
+    end
+  end
+    
+  context 'valid numerator and invalid (zero) denominator' do
+    ["n/d","/d"].each do |expr|
+      it "should parse durations of the form #{expr}" do
+        @valid[:numbers].each do |n|
+          @invalid[:numbers].each do |d|
+            str = expr.gsub('n',"#{n}")
+            str = str.gsub('d',"#{d}")
+            dur_parser.parse(str).should be nil
+          end
+        end
+      end
+    end
+  end
+  
+  context 'invalid numerator and invalid denominator' do
+    ["n","n/","n/d","/d"].each do |expr|
+      it "should parse durations of the form #{expr}" do
+        @invalid[:numbers].each do |n|
+          @invalid[:numbers].each do |d|
+            str = expr.gsub('n',"#{n}")
+            str = str.gsub('d',"#{d}")
+            dur_parser.parse(str).should be nil
+          end
+        end
+      end
+    end
+  end  
+end

data/spec/notation/parsing/link_nodes_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Parsing::LinkNode do
+  parser = Parsing::LinkParser.new
+  
+  {
+    '=C4' => Link::Slur.new(C4),
+    '/Db2' => Link::Portamento.new(Db2),
+    '~C#2' => Link::Glissando.new(Db2),
+    '|Db2' => Link::Legato.new(Db2),
+  }.each do |str,tgt|
+    res = parser.parse(str)
+    context str do
+      it 'should parse as LinkNode' do
+        res.should be_a Parsing::LinkNode
+      end
+      
+      describe '#to_pitch' do
+        l = res.to_link
+        it 'should produce a Link object' do
+          l.should be_a Link
+        end
+        
+        it 'should produce pitch matching input str' do
+          l.should eq tgt
+        end
+      end
+    end
+  end  
+end

data/spec/notation/parsing/link_parsing_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Parsing::LinkParser do
+  before :all do
+    @parser = Parsing::LinkParser.new
+  end
+  
+  ["=C2","|C2","~C2","/C2"].each do |str|
+    it "should parse #{str}" do
+      @parser.should parse(str)
+    end
+  end
+end

data/spec/notation/parsing/meter_parsing_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Parsing::MeterParser do
+  parser = Parsing::MeterParser.new
+  
+  {
+    '4/4' => FOUR_FOUR,
+    '2*3/8' => SIX_EIGHT,
+    '12/3' => Meter.new(12,"1/3".to_r),
+    '3*3/8' => Meter.new(3,"3/8".to_r),
+    '3/4' => THREE_FOUR
+  }.each do |str,met|
+    res = parser.parse(str)
+    
+    it "should parse #{str}" do
+      res.should_not be nil
+    end
+    
+    it 'should produce node that properly converts to meter' do
+      res.to_meter.should eq met
+    end
+  end
+end