music-transcription 0.11.0 → 0.13.0

data/lib/music-transcription/parsing/segment_parsing.treetop

@@ -0,0 +1,25 @@
+module Music
+module Transcription
+module Parsing
+
+grammar Segment
+  include NonnegativeInteger
+  include NonnegativeFloat
+  include NonnegativeRational
+  
+  rule range
+    first:nonnegative_number ([.] 2..3) last:nonnegative_number {
+      def to_range
+        first.to_num...last.to_num
+      end
+    }
+  end
+  
+  rule nonnegative_number
+    nonnegative_float / nonnegative_rational / nonnegative_integer
+  end
+end
+
+end
+end
+end

data/lib/music-transcription/version.rb

@@ -2,6 +2,6 @@
 module Music
 module Transcription
   # music-transcription version
-  VERSION = "0.11.0"
+  VERSION = "0.13.0"
 end
 end

data/spec/model/link_spec.rb

@@ -1,73 +1,51 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe Link::Glissando do
-  describe '#initialize' do
-    it 'should assign the given pitch to :target_pitch' do
-      Link::Glissando.new(C2).target_pitch.should eq(C2)
-    end
-  end
-  
-  describe '#==' do
-    it 'should return true if two links have the same target pitch' do
-      Link::Glissando.new(C2).should eq(Link::Glissando.new(C2))
+{
+  Link::Glissando => Link::Portamento,
+  Link::Portamento => Link::Glissando,
+  Link::Slur => Link::Legato,
+  Link::Legato => Link::Slur
+}.each do |klass,klass2|
+  describe klass do
+    describe '#initialize' do
+      it 'should assign the given pitch to :target_pitch' do
+        klass.new(C2).target_pitch.should eq(C2)
+      end
     end
     
-    it 'should return false if two links do not have the same target pitch' do
-      Link::Glissando.new(C2).should_not eq(Link::Glissando.new(F5))
+    describe '#==' do
+      it 'should return true if two links have the same target pitch' do
+        klass.new(C2).should eq(klass.new(C2))
+      end
+      
+      it 'should return false if two links do not have the same target pitch' do
+        klass.new(C2).should_not eq(klass.new(F5))
+      end
+      
+      it 'should return false if the link type is different' do
+        klass.new(C2).should_not eq(klass2.new(C2))
+      end
     end
     
-    it 'should return false if the link type is different' do
-      Link::Glissando.new(C2).should_not eq(Link::Portamento.new(D2))
-    end
-  end
-  
-  describe '#clone' do
-    it 'should return a link equal to original' do
-      l = Link::Glissando.new(C4)
-      l.clone.should eq l
-    end
-  end
-  
-  describe '#to_yaml' do
-    it 'should produce YAML that can be loaded' do
-      l = Link::Glissando.new(C5)
-      YAML.load(l.to_yaml).should eq l
-    end
-  end
-end
-  
-describe Link::Portamento do
-  describe '#initialize' do
-    it 'should assign the given pitch to :target_pitch' do
-      Link::Portamento.new(C2).target_pitch.should eq(C2)
-    end
-  end
-  
-  describe '#==' do
-    it 'should return true if two links have the same target pitch' do
-      Link::Portamento.new(C2).should eq(Link::Portamento.new(C2))
+    describe '#clone' do
+      it 'should return a link equal to original' do
+        l = klass.new(C4)
+        l.clone.should eq l
+      end
     end
     
-    it 'should return false if two links do not have the same target pitch' do
-      Link::Portamento.new(C2).should_not eq(Link::Portamento.new(F5))
+    describe '#to_yaml' do
+      it 'should produce YAML that can be loaded' do
+        l = klass.new(C5)
+        YAML.load(l.to_yaml).should eq l
+      end
     end
     
-    it 'should return false if the link type is different' do
-      Link::Portamento.new(C2).should_not eq(Link::Glissando.new(D2))
-    end
-  end
-  
-  describe '#clone' do
-    it 'should return a link equal to original' do
-      l = Link::Portamento.new(C4)
-      l.clone.should eq l
-    end
-  end
-  
-  describe '#to_yaml' do
-    it 'should produce YAML that can be loaded' do
-      l = Link::Portamento.new(C5)
-      YAML.load(l.to_yaml).should eq l
+    describe '#to_s' do
+      it 'should produce string that include link char and target pitch str' do
+        l = klass.new(C3)
+        l.to_s.should eq(l.link_char + "C3")
+      end
     end
   end
 end
@@ -96,4 +74,10 @@ describe Link::Tie do
       YAML.load(l.to_yaml).should eq l
     end
   end
+  
+  describe '#to_s' do
+    it 'should return =' do
+      Link::Tie.new.to_s.should eq("=")
+    end
+  end
 end

data/spec/model/meter_spec.rb

@@ -48,6 +48,24 @@ describe Meter do
     end
   end
   
+  describe '#to_s' do
+    context 'beat duration with 1 in denominator' do
+      it 'should return string of fraction: beats_per_measure / beat_duration.denom' do
+        FOUR_FOUR.to_s.should eq("4/4")
+        TWO_FOUR.to_s.should eq("2/4")
+        THREE_FOUR.to_s.should eq("3/4")
+        TWO_TWO.to_s.should eq("2/2")
+      end
+    end
+    
+    context 'beat duration with >1 in denominator' do
+      it 'should return beats_per_measure * beat_dur fraction' do
+        SIX_EIGHT.to_s.should eq("2*3/8")
+        Meter.new(3,"3/8".to_r).to_s.should eq("3*3/8")
+      end
+    end
+  end
+  
   describe '#valid?' do
     {
       '4/4 meter' => [4,'1/4'.to_r],

data/spec/model/note_spec.rb

@@ -122,6 +122,45 @@ describe Note do
     end
   end
   
+  describe '#to_s' do
+    before :all do
+      @note_parser = Parsing::NoteParser.new
+    end
+    
+    context 
+    it 'should produce string that when parsed produces an equal note' do
+      durations = ["1/8".to_r,"1".to_r,"5/3".to_r]
+      include Articulations
+      articulations = [NORMAL, SLUR, LEGATO, TENUTO, PORTATO, STACCATO, STACCATISSIMO ]
+      pitches_links_sets = [
+        [[],{}],
+        [[C2],{}],
+        [[A5,D6],{ A5 => Link::Tie.new }],
+        [[C5,E6,Gb2],{ C5 => Link::Glissando.new(D5) }],
+        [[A5,D6],{ A5 => Link::Legato.new(B5), D6 => Link::Slur.new(E6) }],
+        [[C5,E6,Gb2],{ C5 => Link::Portamento.new(D5), Gb2 => Link::Tie.new }],
+      ]
+      
+      notes = []
+      durations.each do |d|
+        articulations.each do |art|
+          pitches_links_sets.each do |pitches_links_set|
+            pitches,links = pitches_links_set
+            [true,false].each do |acc|
+              notes.push Note.new(d, pitches, articulation: art, links: links, accented: acc)
+            end
+          end
+        end
+      end
+      
+      notes.each do |note|
+        str = note.to_s
+        note2 = @note_parser.parse(str).to_note
+        note2.should eq(note)
+      end
+    end
+  end
+  
   describe '#to_yaml' do
     it 'should produce YAML that can be loaded' do
       n = Note.new(1,[C2])

data/spec/model/pitch_spec.rb

@@ -108,6 +108,38 @@ describe Pitch do
     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
+  end
+
   describe '.make_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|

data/spec/packing/change_packing_spec.rb

@@ -0,0 +1,91 @@
+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)
+      @a = @c.pack
+    end
+    
+    it 'should return an Array' do
+      @a.should be_a Array
+    end
+    
+    it 'should return an Array of size 1' do
+      @a.size.should eq 1
+    end
+    
+    it 'should put the change value at index 0' do
+      @a[0].should eq @c.value
+    end
+  end
+end
+
+describe Change::Gradual do
+  describe '#pack' do
+    before :all do
+      @c = Change::Gradual.new(0.3,1.5)
+      @a = @c.pack
+    end
+    
+    it 'should return an Array' do
+      @a.should be_a Array
+    end
+    
+    it 'should return an Array of size 1' do
+      @a.size.should eq 2
+    end
+    
+    it 'should put the change value at index 0' do
+      @a[0].should eq @c.value
+    end
+    
+    it 'should put the duration at index 1' do
+      @a[1].should eq @c.duration
+    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)
+        @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 duration' do
+        @c2.duration.should eq @c.duration
+      end
+    end
+  end
+end

data/spec/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: Parsing::notes("/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/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