jmtk 0.0.3.3-java → 0.4-java

data/spec/mtk/lang/durations_spec.rb

@@ -29,12 +29,12 @@ describe MTK::Lang::Durations do
     end
   end
 
-  describe 'i' do
+  describe 'e' do
     it 'is 1/2 of a beat' do
-      i.value.should == 1.0/2
+      e.value.should == 1.0/2
     end
     it 'is available via a module property and via mixin' do
-      Durations::i.should == i
+      Durations::e.should == e
     end
   end
 
@@ -67,7 +67,7 @@ describe MTK::Lang::Durations do
 
   describe "DURATIONS" do
     it "contains all Durations pseudo-constants" do
-      Durations::DURATIONS.should =~ [w, h, q, i, s, r, x]
+      Durations::DURATIONS.should =~ [w, h, q, e, s, r, x]
     end
 
     it "is immutable" do
@@ -77,7 +77,7 @@ describe MTK::Lang::Durations do
 
   describe "DURATION_NAMES" do
     it "contains all Durations pseudo-constants names as strings" do
-      Durations::DURATION_NAMES.should =~ ['w', 'h', 'q', 'i', 's', 'r', 'x']
+      Durations::DURATION_NAMES.should =~ ['w', 'h', 'q', 'e', 's', 'r', 'x']
     end
 
     it "is immutable" do

data/spec/mtk/lang/intensities_spec.rb

@@ -47,12 +47,12 @@ describe MTK::Lang::Intensities do
     end    
   end
 
-  describe 'o' do # AKA forte
+  describe 'f' do # AKA forte
     it 'is equivalent to MIDI velocity 95' do
-      (o.value * 127).round.should == 95
+      (f.value * 127).round.should == 95
     end
     it 'is available via a module property and via mixin' do
-      Intensities::o.should == o
+      Intensities::f.should == f
     end
     it "does not overwrite the PitchClass constant 'F'" do
       F.should be_a PitchClass
@@ -79,7 +79,7 @@ describe MTK::Lang::Intensities do
 
   describe "INTENSITIES" do
     it "contains all Intensities pseudo-constants" do
-      Intensities::INTENSITIES.should =~ [ppp, pp, p, mp, mf, o, ff, fff]
+      Intensities::INTENSITIES.should =~ [ppp, pp, p, mp, mf, f, ff, fff]
     end
 
     it "is immutable" do
@@ -89,7 +89,7 @@ describe MTK::Lang::Intensities do
 
   describe "INTENSITY_NAMES" do
     it "contains all Intensities pseudo-constants names as strings" do
-      Intensities::INTENSITY_NAMES.should =~ ['ppp', 'pp', 'p', 'mp', 'mf', 'o', 'ff', 'fff']
+      Intensities::INTENSITY_NAMES.should =~ ['ppp', 'pp', 'p', 'mp', 'mf', 'f', 'ff', 'fff']
     end
 
     it "is immutable" do

data/spec/mtk/lang/intervals_spec.rb

@@ -11,12 +11,30 @@ describe MTK::Lang::Intervals do
     end
   end
 
+  describe 'd2' do
+    it 'is 0 semitones' do
+      d2.should == Interval[0]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::d2.should == d2
+    end
+  end
+
   describe 'm2' do
     it 'is 1 semitone' do
       m2.should == Interval[1]
     end
     it 'is available via a module property and via mixin' do
-      Intervals::P1.should == P1
+      Intervals::m2.should == m2
+    end
+  end
+
+  describe 'a1' do
+    it 'is 1 semitone' do
+      a1.should == Interval[1]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::a1.should == a1
     end
   end
 
@@ -25,7 +43,16 @@ describe MTK::Lang::Intervals do
       M2.should == Interval[2]
     end
     it 'is available via a module property and via mixin' do
-      Intervals::P1.should == P1
+      Intervals::M2.should == M2
+    end
+  end
+
+  describe 'd3' do
+    it 'is 2 semitones' do
+      d3.should == Interval[2]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::d3.should == d3
     end
   end
 
@@ -34,7 +61,16 @@ describe MTK::Lang::Intervals do
       m3.should == Interval[3]
     end
     it 'is available via a module property and via mixin' do
-      Intervals::P1.should == P1
+      Intervals::m3.should == m3
+    end
+  end
+
+  describe 'a2' do
+    it 'is 3 semitones' do
+      a2.should == Interval[3]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::a2.should == a2
     end
   end
 
@@ -43,7 +79,16 @@ describe MTK::Lang::Intervals do
       M3.should == Interval[4]
     end
     it 'is available via a module property and via mixin' do
-      Intervals::P1.should == P1
+      Intervals::M3.should == M3
+    end
+  end
+
+  describe 'd4' do
+    it 'is 4 semitones' do
+      d4.should == Interval[4]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::d4.should == d4
     end
   end
 
@@ -52,7 +97,16 @@ describe MTK::Lang::Intervals do
       P4.should == Interval[5]
     end
     it 'is available via a module property and via mixin' do
-      Intervals::P1.should == P1
+      Intervals::P4.should == P4
+    end
+  end
+
+  describe 'a3' do
+    it 'is 5 semitones' do
+      a3.should == Interval[5]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::a3.should == a3
     end
   end
 
@@ -61,7 +115,25 @@ describe MTK::Lang::Intervals do
       TT.should == Interval[6]
     end
     it 'is available via a module property and via mixin' do
-      Intervals::P1.should == P1
+      Intervals::TT.should == TT
+    end
+  end
+
+  describe 'a4' do
+    it 'is 6 semitones' do
+      a4.should == Interval[6]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::a4.should == a4
+    end
+  end
+
+  describe 'd5' do
+    it 'is 6 semitones' do
+      d5.should == Interval[6]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::d5.should == d5
     end
   end
 
@@ -70,7 +142,16 @@ describe MTK::Lang::Intervals do
       P5.should == Interval[7]
     end
     it 'is available via a module property and via mixin' do
-      Intervals::P1.should == P1
+      Intervals::P5.should == P5
+    end
+  end
+
+  describe 'd6' do
+    it 'is 7 semitones' do
+      d6.should == Interval[7]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::d6.should == d6
     end
   end
 
@@ -83,12 +164,30 @@ describe MTK::Lang::Intervals do
     end
   end
 
+  describe 'a5' do
+    it 'is 8 semitones' do
+      a5.should == Interval[8]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::a5.should == a5
+    end
+  end
+
   describe 'M6' do
     it 'is 9 semitones' do
       M6.should == Interval[9]
     end
     it 'is available via a module property and via mixin' do
-      Intervals::P1.should == P1
+      Intervals::M6.should == M6
+    end
+  end
+
+  describe 'd7' do
+    it 'is 9 semitones' do
+      d7.should == Interval[9]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::d7.should == d7
     end
   end
 
@@ -97,7 +196,16 @@ describe MTK::Lang::Intervals do
       m7.should == Interval[10]
     end
     it 'is available via a module property and via mixin' do
-      Intervals::P1.should == P1
+      Intervals::m7.should == m7
+    end
+  end
+
+  describe 'a6' do
+    it 'is 10 semitones' do
+      a6.should == Interval[10]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::a6.should == a6
     end
   end
 
@@ -106,7 +214,16 @@ describe MTK::Lang::Intervals do
       M7.should == Interval[11]
     end
     it 'is available via a module property and via mixin' do
-      Intervals::P1.should == P1
+      Intervals::M7.should == M7
+    end
+  end
+
+  describe 'd8' do
+    it 'is 11 semitones' do
+      d8.should == Interval[11]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::d8.should == d8
     end
   end
 
@@ -115,14 +232,23 @@ describe MTK::Lang::Intervals do
       P8.should == Interval[12]
     end
     it 'is available via a module property and via mixin' do
-      Intervals::P1.should == P1
+      Intervals::P8.should == P8
+    end
+  end
+
+  describe 'a7' do
+    it 'is 12 semitones' do
+      a7.should == Interval[12]
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::a7.should == a7
     end
   end
 
 
   describe "INTERVALS" do
     it "contains all intervals constants/pseudo-constants" do
-      Intervals::INTERVALS.should =~ [P1, m2, M2, m3, M3, P4, TT, P5, m6, M6, m7, M7, P8]
+      Intervals::INTERVALS.should =~ MTK::Core::Interval::ALL_NAMES.map{|name| MTK::Core::Interval.from_name(name) }
     end
 
     it "is immutable" do
@@ -132,7 +258,7 @@ describe MTK::Lang::Intervals do
 
   describe "INTERVAL_NAMES" do
     it "contains all intervals constants/pseudo-constant names" do
-      Intervals::INTERVAL_NAMES.should =~ ['P1', 'm2', 'M2', 'm3', 'M3', 'P4', 'TT', 'P5', 'm6', 'M6', 'm7', 'M7', 'P8']
+      Intervals::INTERVAL_NAMES.should =~ MTK::Core::Interval::ALL_NAMES
     end
 
     it "is immutable" do

data/spec/mtk/lang/parser_spec.rb

@@ -34,31 +34,31 @@ describe MTK::Lang::Parser do
 
   describe ".parse" do
     it "can parse a single pitch class and play it" do
-      sequencer = MTK::Lang::Parser.parse('c')
+      sequencer = MTK::Lang::Parser.parse('C')
       timeline = sequencer.to_timeline
       timeline.should ==  MTK::Events::Timeline.from_h({0 => MTK.Note(C4)})
     end
 
     context "default (root rule) behavior" do
       it "parses a bare_sequencer" do
-        sequencer = parse('C:q:mp D4:ff A i:p Eb:pp Bb7 F2:h. F#4:mf:s q ppp')
+        sequencer = parse('C:q:mp D4:ff A e:p Eb:pp Bb7 F2:h. F#4:mf:s q ppp')
         sequencer.should be_a Sequencers::Sequencer
-        sequencer.patterns.should == [seq( chain(C,q,mp), chain(D4,ff), A, chain(i,p), chain(Eb,pp), Bb7, chain(F2,h+q), chain(Gb4,mf,s), q, ppp )]
+        sequencer.patterns.should == [seq( chain(C,q,mp), chain(D4,ff), A, chain(e,p), chain(Eb,pp), Bb7, chain(F2,h+q), chain(Gb4,mf,s), q, ppp )]
       end
 
       it "parses a sequencer" do
-        sequencer = parse('( C:q:mp D4:ff A i:p Eb:pp Bb7 F2:h. F#4:mf:s q ppp  )')
+        sequencer = parse('( C:q:mp D4:ff A e:p Eb:pp Bb7 F2:h. F#4:mf:s q ppp  )')
         sequencer.should be_a Sequencers::Sequencer
-        sequencer.patterns.should == [seq( chain(C,q,mp), chain(D4,ff), A, chain(i,p), chain(Eb,pp), Bb7, chain(F2,h+q), chain(Gb4,mf,s), q, ppp )]
+        sequencer.patterns.should == [seq( chain(C,q,mp), chain(D4,ff), A, chain(e,p), chain(Eb,pp), Bb7, chain(F2,h+q), chain(Gb4,mf,s), q, ppp )]
       end
 
       it "parses a timeline" do
         parse("
           {
             0 => C4:mp:q
-            1 => D4:o:h
+            1 => D4:f:h
           }
-        ").should ==  MTK::Events::Timeline.from_h({0 => chain(C4,mp,q), 1 => chain(D4,o,h)})
+        ").should ==  MTK::Events::Timeline.from_h({0 => chain(C4,mp,q), 1 => chain(D4,f,h)})
       end
 
       it "parses a chain of sequences" do
@@ -68,17 +68,17 @@ describe MTK::Lang::Parser do
       end
 
       it "parses a chain of choices" do
-        sequencer = parse("<i|s>:<c|d|e>")
-        sequencer.patterns.should == [ chain( choice(i,s), choice(C,D,E) ) ]
+        sequencer = parse("<e|s>:<C|D|E>")
+        sequencer.patterns.should == [ chain( choice(e,s), choice(C,D,E) ) ]
       end
 
       it "parses a chain of choices" do
-        sequencer = parse("(<i|s>:<c|d|e>)&8")
-        sequencer.patterns.should == [ seq( chain( choice(i,s), choice(C,D,E) ), min_elements:8, max_elements:8 ) ]
+        sequencer = parse("(<e|s>:<C|D|E>)&8")
+        sequencer.patterns.should == [ seq( chain( choice(e,s), choice(C,D,E) ), min_elements:8, max_elements:8 ) ]
       end
 
       it "parses the repetition of a basic note property" do
-        sequencer = parse("c*4")
+        sequencer = parse("C*4")
         sequencer.patterns.should == [ seq(C, max_cycles:4) ]
       end
     end
@@ -104,15 +104,15 @@ describe MTK::Lang::Parser do
       end
 
       it "parses pitchclass:duration chains" do
-        sequencer = parse('C:q D:q E:i F:i G:h', :bare_sequencer)
+        sequencer = parse('C:q D:q E:e F:e G:h', :bare_sequencer)
         sequencer.should be_a Sequencers::Sequencer
-        sequencer.patterns.should == [seq(chain(C,q), chain(D,q), chain(E,i), chain(F,i), chain(G,h))]
+        sequencer.patterns.should == [seq(chain(C,q), chain(D,q), chain(E,e), chain(F,e), chain(G,h))]
       end
 
       it "parses a mix of chained and unchained pitches, pitch classes, durations, and intensities" do
-        sequencer = parse('C:q:mp D4:ff A i:p Eb:pp Bb7 F2:h. F#4:mf:s q ppp', :bare_sequencer)
+        sequencer = parse('C:q:mp D4:ff A e:p Eb:pp Bb7 F2:h. F#4:mf:s q ppp', :bare_sequencer)
         sequencer.should be_a Sequencers::Sequencer
-        sequencer.patterns.should == [seq( chain(C,q,mp), chain(D4,ff), A, chain(i,p), chain(Eb,pp), Bb7, chain(F2,h+q), chain(Gb4,mf,s), q, ppp )]
+        sequencer.patterns.should == [seq( chain(C,q,mp), chain(D4,ff), A, chain(e,p), chain(Eb,pp), Bb7, chain(F2,h+q), chain(Gb4,mf,s), q, ppp )]
       end
     end
 
@@ -137,15 +137,15 @@ describe MTK::Lang::Parser do
       end
 
       it "parses pitchclass:duration chains" do
-        sequencer = parse('{  C:q D:q E:i F:i G:h }', :sequencer)
+        sequencer = parse('{  C:q D:q E:e F:e G:h }', :sequencer)
         sequencer.should be_a Sequencers::Sequencer
-        sequencer.patterns.should == [seq(chain(C,q), chain(D,q), chain(E,i), chain(F,i), chain(G,h))]
+        sequencer.patterns.should == [seq(chain(C,q), chain(D,q), chain(E,e), chain(F,e), chain(G,h))]
       end
 
       it "parses a mix of chained and unchained pitches, pitch classes, durations, and intensities" do
-        sequencer = parse('{ C:q:mp D4:ff A i:p Eb:pp Bb7 F2:h. F#4:mf:s q ppp   }', :sequencer)
+        sequencer = parse('{ C:q:mp D4:ff A e:p Eb:pp Bb7 F2:h. F#4:mf:s q ppp   }', :sequencer)
         sequencer.should be_a Sequencers::Sequencer
-        sequencer.patterns.should == [seq( chain(C,q,mp), chain(D4,ff), A, chain(i,p), chain(Eb,pp), Bb7, chain(F2,h+q), chain(Gb4,mf,s), q, ppp )]
+        sequencer.patterns.should == [seq( chain(C,q,mp), chain(D4,ff), A, chain(e,p), chain(Eb,pp), Bb7, chain(F2,h+q), chain(Gb4,mf,s), q, ppp )]
       end
     end
 
@@ -167,9 +167,9 @@ describe MTK::Lang::Parser do
         parse("
           {
             0 => C4:mp:q
-            1 => D4:o:h
+            1 => D4:f:h
           }
-        ", :timeline).should ==  MTK::Events::Timeline.from_h({0 => chain(C4,mp,q), 1 => chain(D4,o,h)})
+        ", :timeline).should ==  MTK::Events::Timeline.from_h({0 => chain(C4,mp,q), 1 => chain(D4,f,h)})
       end
 
       #it "parses a Timeline containing a chord" do
@@ -317,7 +317,7 @@ describe MTK::Lang::Parser do
       end
 
       it "parses duration sequences" do
-        parse("q i q. ht", :bare_sequence).should == seq(q, i, q*Rational(1.5), h*Rational(2,3))
+        parse("q e q. ht", :bare_sequence).should == seq(q, e, q*Rational(1.5), h*Rational(2,3))
       end
     end
 
@@ -344,7 +344,7 @@ describe MTK::Lang::Parser do
       end
 
       it "parses duration sequences" do
-        parse("(q i q. ht)", :sequence).should == seq(q, i, q*Rational(1.5), h*Rational(2,3))
+        parse("(q e q. ht)", :sequence).should == seq(q, e, q*Rational(1.5), h*Rational(2,3))
       end
 
       it "parses sequences with a max_cycles modifier" do
@@ -424,7 +424,7 @@ describe MTK::Lang::Parser do
 
     context 'element rule' do
       it "parses the repetition of a basic note property as a sequence with a max_cycles option" do
-        sequence = parse("c*4", :element)
+        sequence = parse("C*4", :element)
         sequence.elements.should == [ C ]
         sequence.max_cycles.should == 4
       end
@@ -456,6 +456,46 @@ describe MTK::Lang::Parser do
           parse(pitch_class_name, :pitch_class).should == PitchClass[pitch_class_name]
         end
       end
+
+      it "doesn't allow a sharp and flat to be applied to the same diatonic pitch class" do
+        for pitch_class_name in %w(A B C D E F G)
+          lambda{ parse(pitch_class_name + '#b', :pitch_class) }.should raise_error
+          lambda{ parse(pitch_class_name + 'b#', :pitch_class) }.should raise_error
+        end
+      end
+    end
+
+
+    context 'diatonic_pitch_class rule' do
+      it "parses upper case diatonic pitch classes" do
+        for diatonic_pitch_class_name in %w(A B C D E F G)
+          parse(diatonic_pitch_class_name, :diatonic_pitch_class).should == PitchClass[diatonic_pitch_class_name]
+        end
+      end
+    end
+
+
+    context 'accidental rule' do
+      it "parses a single flat 'b'" do
+        lambda{ parse('b', :accidental) }.should_not raise_error
+      end
+
+      it "parses a double flat 'bb'" do
+        lambda{ parse('bb', :accidental) }.should_not raise_error
+      end
+
+      it "parses a single sharp '#'" do
+        lambda{ parse('#', :accidental) }.should_not raise_error
+      end
+
+      it "parses a double sharp '##'" do
+        lambda{ parse('##', :accidental) }.should_not raise_error
+      end
+
+      it "doesn't parse trip flats or sharps" do
+        lambda{ parse('bbb', :accidental) }.should raise_error
+        lambda{ parse('###', :accidental) }.should raise_error
+      end
     end