mtk 0.0.2 → 0.0.3

data/spec/mtk/lang/grammar_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-require 'mtk/lang/grammar'
-
-describe MTK::Lang::Grammar do
-
-  def parse syntax, root
-    MTK::Lang::Grammar.parse(syntax, root)
-  end
-
-  describe ".parse" do
-
-    it "should parse pitch sequences" do
-      parse("C4 D4 E4", :pitch_sequence).should == Pattern.PitchSequence(C4, D4, E4)
-    end
-
-    it "should parse pitches" do
-      for pitch_class_name in PitchClass::VALID_NAMES
-        for octave in -1..9
-          parse("#{pitch_class_name}#{octave}", :pitch).should == Pitch[PitchClass[pitch_class_name],octave]
-        end
-      end
-    end
-
-    it "should parse pitch classes" do
-      for pitch_class_name in PitchClass::VALID_NAMES
-        parse(pitch_class_name, :pitch_class).should == PitchClass[pitch_class_name]
-      end
-    end
-
-    it "should parse intervals" do
-      for interval_name in Intervals::INTERVAL_NAMES
-        parse(interval_name, :interval).should == Intervals[interval_name]
-      end
-    end
-
-    it "should parse intensities" do
-      for intensity_name in Intensities::INTENSITY_NAMES
-        parse(intensity_name, :intensity).should == Intensities[intensity_name]
-      end
-    end
-
-    it "should parse intensities with + and - modifiers" do
-      for intensity_name in Intensities::INTENSITY_NAMES
-        name = "#{intensity_name}+"
-        parse(name, :intensity).should == Intensities[name]
-        name = "#{intensity_name}-"
-        parse(name, :intensity).should == Intensities[name]
-      end
-    end
-
-    it "should parse durations" do
-      for duration in Durations::DURATION_NAMES
-        parse(duration, :duration).should == Durations[duration]
-      end
-    end
-
-    it "should parse durations with . and t modifiers" do
-      for duration in Durations::DURATION_NAMES
-        name = "#{duration}."
-        parse(name, :duration).should == Durations[name]
-        name = "#{duration}t"
-        parse(name, :duration).should == Durations[name]
-        name = "#{duration}..t.t"
-        parse(name, :duration).should == Durations[name]
-      end
-    end
-
-    it "should parse ints as numbers" do
-      parse("123", :number).should == 123
-    end
-
-    it "should parse floats as numbers" do
-      parse("1.23", :number).should == 1.23
-    end
-
-    it "should parse floats" do
-      parse("1.23", :float).should == 1.23
-    end
-
-    it "should parse negative floats" do
-      parse("-1.23", :float).should == -1.23
-    end
-
-    it "should parse ints" do
-      parse("123", :int).should == 123
-    end
-
-    it "should parse negative ints" do
-      parse("-123", :int).should == -123
-    end
-
-    it "should parse negative ints" do
-      parse("-123", :int).should == -123
-    end
-
-    it "should give nil as the value for whitespace" do
-      parse(" \t\n", :space).should == nil
-    end
-  end
-end

data/spec/mtk/note_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-describe MTK::Note do
-
-  let(:pitch) { C4 }
-  let(:intensity) { mf }
-  let(:duration) { 2.5 }
-  let(:note) { Note.new(pitch, intensity, duration) }
-
-  describe "#pitch" do
-    it "is the pitch used to create the Note" do
-      note.pitch.should == pitch
-    end
-
-    it "is a read-only attribute" do
-      lambda{ note.pitch = D4 }.should raise_error
-    end
-  end
-
-  describe ".from_hash" do
-    it "constructs a Note using a hash" do
-      Note.from_hash({ :pitch => C4, :intensity => intensity, :duration => duration }).should == note
-    end
-  end
-
-  describe '.from_midi' do
-    it "constructs a Note using a MIDI pitch and velocity" do
-      Note.from_midi(C4.to_i, mf*127, 2.5).should == note
-    end
-  end
-
-  describe "#to_midi" do
-    it "converts the Note to an Array of MIDI values: [pitch, velocity, duration]" do
-      note.to_midi.should == [60, (mf*127).round, duration]
-    end
-  end
-
-  describe "#to_hash" do
-    it "is a hash containing all the attributes of the Note" do
-      note.to_hash.should == { :pitch => pitch, :intensity => intensity, :duration => duration }
-    end
-  end
-
-  describe '#transpose' do
-    it 'adds the given interval to the @pitch' do
-      (note.transpose 2.semitones).should == Note.new(D4, intensity, duration)
-    end
-    it 'does not affect the immutability of the Note' do
-      (note.transpose 2.semitones).should_not == note
-    end
-  end
-
-  describe "#invert" do
-    context 'higher center pitch' do
-      it 'inverts the pitch around the given center pitch' do
-        note.invert(Pitch 66).should == Note.new(Pitch(72), intensity, duration)
-      end
-    end
-
-    context 'lower center pitch' do
-      it 'inverts the pitch around the given center pitch' do
-        note.invert(Pitch 54).should == Note.new(Pitch(48), intensity, duration)
-      end
-    end
-
-    it "returns the an equal note when given it's pitch as an argument" do
-      note.invert(note.pitch).should == note
-    end
-  end
-
-  describe "#==" do
-    it "is true when the pitches, intensities, and durations are equal" do
-      note.should == Note.new(pitch, intensity, duration)
-    end
-
-    it "is false when the pitches are not equal" do
-      note.should_not == Note.new(pitch + 1, intensity, duration)
-    end
-
-    it "is false when the intensities are not equal" do
-      note.should_not == Note.new(pitch, intensity * 0.5, duration)
-    end
-
-    it "is false when the durations are not equal" do
-      note.should_not == Note.new(pitch, intensity, duration * 2)
-    end
-  end
-
-end
-
-describe MTK do
-
-  describe '#Note' do
-
-    it "acts like new for multiple arguments" do
-      Note(C4,mf,1).should == Note.new(C4,mf,1)
-    end
-
-    it "acts like new for an Array of arguments by unpacking (splatting) them" do
-      Note([C4,mf,1]).should == Note.new(C4,mf,1)
-    end
-
-    it "returns the argument if it's already a Note" do
-      note = Note.new(C4,mf,1)
-      Note(note).should be_equal note
-    end
-
-    it "raises an error for types it doesn't understand" do
-      lambda{ Note({:not => :compatible}) }.should raise_error
-    end
-
-  end
-
-end
-

data/spec/mtk/pattern/abstract_pattern_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe MTK::Pattern::AbstractPattern do
-
-  PATTERN = MTK::Pattern::AbstractPattern
-
-  let(:elements) { [1,2,3] }
-
-  describe "#type" do
-    it "is the :type value from the constuctor's options hash" do
-      PATTERN.new([], :type => :my_type).type.should == :my_type
-    end
-  end
-
-  describe "#max_elements" do
-    it "is the :max_elements option the pattern was constructed with" do
-      PATTERN.new([], :max_elements => 1).max_elements.should == 1
-    end
-
-    it "is nil by default" do
-      PATTERN.new([]).max_elements.should be_nil
-    end
-
-    it "causes a StopIteration exception after the number of elements have been emitted" do
-      cycle = PATTERN.new([:anything], :max_elements => 5)
-      5.times { cycle.next }
-      lambda { cycle.next }.should raise_error
-    end
-  end
-
-  describe "#==" do
-    it "is true if the elements and types are equal" do
-      PATTERN.new(elements, :type => :some_type).should == PATTERN.new(elements, :type => :some_type)
-    end
-
-    it "is false if the elements are not equal" do
-      PATTERN.new(elements, :type => :some_type).should_not == PATTERN.new(elements + [4], :type => :some_type)
-    end
-
-    it "is false if the types are not equal" do
-      PATTERN.new(elements, :type => :some_type).should_not == PATTERN.new(elements, :type => :another_type)
-    end
-  end
-
-end

data/spec/mtk/pattern/note_cycle_spec.rb.bak

@@ -1,116 +0,0 @@
-require 'spec_helper'
-
-describe MTK::Pattern::NoteCycle do
-
-  def note(pitch, intensity=mf, duration=1)
-    Note(pitch, intensity, duration)
-  end
-
-  describe "#new" do
-    it "allows default pitch to be specified" do
-      cycle = Pattern::NoteCycle.new [], [p], [1], :pitch => Gb4
-      cycle.next.should == Note(Gb4, p, 1)
-    end
-    it "allows default intensity to be specified" do
-      cycle = Pattern::NoteCycle.new [C4], [], [1], :intensity => ppp
-      cycle.next.should == Note(C4, ppp, 1)
-    end
-    it "allows default duration to be specified" do
-      cycle = Pattern::NoteCycle.new [C4], [mf], [], :duration => 12
-      cycle.next.should == Note(C4, mf, 12)
-    end
-  end
-
-  describe "#next" do
-    it "iterates through the pitch, intensity, and duration list in parallel to emit Notes" do
-      cycle = Pattern::NoteCycle.new [C4, D4, E4], [p, f], [1,2,3,4]
-      cycle.next.should == Note(C4, p, 1)
-      cycle.next.should == Note(D4, f, 2)
-      cycle.next.should == Note(E4, p, 3)
-      cycle.next.should == Note(C4, f, 4)
-      cycle.next.should == Note(D4, p, 1)
-      cycle.next.should == Note(E4, f, 2)
-    end
-
-    it "defaults to Pitch 'C4' when no pitches are given" do
-      cycle = Pattern::NoteCycle.new [], [p,f], [1,2,3]
-      cycle.next.should == Note(C4, p, 1)
-      cycle.next.should == Note(C4, f, 2)
-      cycle.next.should == Note(C4, p, 3)
-    end
-
-    it "defaults to intensity 'mf' when no intensities are given" do
-      cycle = Pattern::NoteCycle.new [C4, D4, E4], nil, [2]
-      cycle.next.should == Note(C4, mf, 2)
-      cycle.next.should == Note(D4, mf, 2)
-      cycle.next.should == Note(E4, mf, 2)
-    end
-
-    it "defaults to duration 1 when no durations are given" do
-      cycle = Pattern::NoteCycle.new [C4, D4, E4], [p, f]
-      cycle.next.should == Note(C4, p, 1)
-      cycle.next.should == Note(D4, f, 1)
-      cycle.next.should == Note(E4, p, 1)
-    end
-
-    it "uses the previous pitch/intensity/duration when it encounters a nil value" do
-      cycle = Pattern::NoteCycle.new [C4, D4, E4, F4, nil], [mp, mf, f, nil], [1, 2, nil]
-      cycle.next.should == Note(C4, mp, 1)
-      cycle.next.should == Note(D4, mf, 2)
-      cycle.next.should == Note(E4, f, 2)
-      cycle.next.should == Note(F4, f, 1)
-      cycle.next.should == Note(F4, mp, 2)
-      cycle.next.should == Note(C4, mf, 2)
-    end
-
-    it "adds Numeric intervals in the pitch list to the previous pitch" do
-      cycle = Pattern::NoteCycle.new [C4, 1, 2, 3]
-      cycle.next.should == note(C4)
-      cycle.next.should == note(C4+1)
-      cycle.next.should == note(C4+1+2)
-      cycle.next.should == note(C4+1+2+3)
-      cycle.next.should == note(C4)
-    end
-
-    it "goes to the nearest Pitch for any PitchClasses in the pitch list" do
-      cycle = Pattern::NoteCycle.new [C4, F, C, G, C]
-      cycle.next.should == note(C4)
-      cycle.next.should == note(F4)
-      cycle.next.should == note(C4)
-      cycle.next.should == note(G3)
-      cycle.next.should == note(C4)
-    end
-
-    it "does not endlessly ascend or descend when alternating between two pitch classes a tritone apart" do
-      cycle = Pattern::NoteCycle.new [C4, Gb, C, Gb, C]
-      cycle.next.should == note(C4)
-      cycle.next.should == note(Gb4)
-      cycle.next.should == note(C4)
-      cycle.next.should == note(Gb4)
-      cycle.next.should == note(C4)
-    end
-
-    it "cycles Note Arrays for pitch list items that are PitchSets" do
-      cycle = Pattern::NoteCycle.new [PitchSet.new([C4, E4, G4]), C4, PitchSet.new([D4, F4, A4])]
-      cycle.next.should == [note(C4), note(E4), note(G4)]
-      cycle.next.should == note(C4)
-      cycle.next.should == [note(D4), note(F4), note(A4)]
-    end
-
-    it "adds numeric intervals to PitchSets" do
-      cycle = Pattern::NoteCycle.new [PitchSet.new([C4, E4, G4]), 2]
-      cycle.next.should == [note(C4), note(E4), note(G4)]
-      cycle.next.should == [note(D4), note(Gb4), note(A4)]
-    end
-
-    it "goes to the nearest Pitch relative to the lowest note in the PitchSet for any PitchClasses in the pitch list" do
-      cycle = Pattern::NoteCycle.new [PitchSet.new([C4, E4, G4]), F, D, Bb]
-      cycle.next.should == [note(C4), note(E4), note(G4)]
-      cycle.next.should == [note(F4), note(A4), note(C5)]
-      cycle.next.should == [note(D4), note(Gb4), note(A4)]
-      cycle.next.should == [note(Bb3), note(D4), note(F4)]
-    end
-  end
-
-
-end

data/spec/mtk/pattern/pitch_cycle_spec.rb.bak

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe MTK::Pattern::PitchCycle do
-
-  describe "#next" do
-    it "enumerates Pitches" do
-      cycle = Pattern::PitchCycle.new [C4, D4, E4]
-      cycle.next.should == C4
-      cycle.next.should == D4
-      cycle.next.should == E4
-    end
-
-    it "adds Numeric elements (intervals) to the previous pitch" do
-      cycle = Pattern::PitchCycle.new [C4, 1, 2, 3]
-      cycle.next.should == C4
-      cycle.next.should == C4+1
-      cycle.next.should == C4+1+2
-      cycle.next.should == C4+1+2+3
-    end
-
-    it "returns a Pitch when encountering a Pitch after another type" do
-      cycle = Pattern::PitchCycle.new [C4, 1, C4]
-      cycle.next
-      cycle.next
-      cycle.next.should == C4
-    end
-
-    it "goes to the nearest Pitch for any PitchClasses in the pitch list" do
-      cycle = Pattern::PitchCycle.new [C4, F, C, G, C]
-      cycle.next.should == C4
-      cycle.next.should == F4
-      cycle.next.should == C4
-      cycle.next.should == G3
-      cycle.next.should == C4
-    end
-
-    it "does not endlessly ascend or descend when alternating between two pitch classes a tritone apart" do
-      cycler = Pattern::PitchCycle.new [C4, Gb, C, Gb, C]
-      cycler.next.should == C4
-      cycler.next.should == Gb4
-      cycler.next.should == C4
-      cycler.next.should == Gb4
-      cycler.next.should == C4
-    end
-
-  end
-end

data/spec/mtk/pattern/pitch_sequence_spec.rb.bak

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe MTK::Pattern::PitchSequence do
-
-  let(:pitches) { [C4,D4,E4] }
-  let(:pitch_sequence) { Pattern::PitchSequence.new(pitches) }
-
-
-  describe ".from_pitch_classes" do
-    it "creates a pitch sequence from a list of pitch classes and starting point, selecting the nearest pitch to each pitch class" do
-      Pattern::PitchSequence.from_pitch_classes([C,G,B,Eb,D,C], D3).should == [C3,G2,B2,Eb3,D3,C3]
-    end
-
-    it "defaults to a starting point of C4 (middle C)" do
-      Pattern::PitchSequence.from_pitch_classes([C]).should == [C4]
-    end
-
-    it "doesn't travel within an octave above or below the starting point by default" do
-      Pattern::PitchSequence.from_pitch_classes([C,F,Bb,D,A,E,B]).should == [C4,F4,Bb4,D4,A3,E3,B3]
-    end
-
-    it "allows max distance above or below the starting point to be set via the third argument" do
-      Pattern::PitchSequence.from_pitch_classes([C,F,Bb,D,A,E,B], C4, 6).should == [C4,F4,Bb3,D4,A3,E4,B3]
-    end
-  end
-
-
-end
-
-describe MTK::Pattern do
-
-    it "converts the arguments to Pitches when possible" do
-      Pattern.PitchSequence(:C4,:D4,:E4).elements.should == [C4,D4,E4]
-    end
-  end
-
-end