musicality 0.9.0 → 0.10.0

data/lib/musicality/project/create_tasks.rb

@@ -2,7 +2,7 @@ module Musicality
 
 class Project
   def self.create_tasks config
-    score_files = Rake::FileList[File.join(config[:scores_dir],"**/*.score")]
+    score_files = Rake::FileList[config[:scores]]
     
     yaml_task = Tasks::FileRaker::YAML.new(score_files)
     

data/lib/musicality/project/load_config.rb

@@ -2,9 +2,10 @@ module Musicality
 
 class Project
   CONFIG_FILE_NAME = "config.yml"
+  BASE_SCORES_DIR = "scores"
 
   DEFAULT_CONFIG = {
-    :scores_dir => "scores",
+    :scores => File.join(BASE_SCORES_DIR, "**", "*.score"),
     :tempo_sample_rate => 200,
     :audio_sample_rate => 44100, 
     :audio_sample_format => "int16"
@@ -35,6 +36,20 @@ class Project
     else
       DEFAULT_CONFIG
     end
+
+    # overrides from ENV
+    config.keys.each do |k|
+      k_str = k.to_s
+      if ENV.has_key? k_str
+        case k
+        when :tempo_sample_rate, :audio_sample_rate
+          config[k] = ENV[k_str].to_i
+        else
+          config[k] = ENV[k_str]
+        end
+      end
+    end
+
     check_config config
     return config
   end

data/lib/musicality/project/project.rb

@@ -24,7 +24,7 @@ class Project
       unless Dir.exists?(dest_dir)
         raise "directory #{dest_dir} could not be created"
       end
-    end    
+    end
   end
 
   def create_gemfile
@@ -56,7 +56,7 @@ class Project
   end
 
   def create_scores_dir
-    scores_dir = File.join(dest_dir, Project::DEFAULT_CONFIG[:scores_dir])
+    scores_dir = File.join(dest_dir, Project::BASE_SCORES_DIR)
     Dir.mkdir(scores_dir)
   end
 end

data/lib/musicality/version.rb

@@ -1,3 +1,3 @@
 module Musicality
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/musicality.gemspec

@@ -28,7 +28,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "treetop", "~> 1.5"
   spec.add_dependency 'midilib', '~> 2.0'
   spec.add_dependency 'docopt', '~> 0.5'
-  spec.add_dependency 'ruby-osc', '~> 0.4'
 
   spec.required_ruby_version = '>= 2.0'
 end

data/spec/composition/dsl/score_methods_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Score do
+  describe '#notes' do
+    before :all do
+      @equal_duration_note_sets = [
+        [ Note.quarter, Note.half ],
+        [ Note.eighth, Note.half, Note.eighth ],
+        "/2 /12 /12 /12".to_notes,
+      ]
+    end
+
+    context 'given two parts' do
+      before :all do
+        @notes_a = "/4C2 /4Bb2 /2D4".to_notes
+        @notes_b = "/8 /8F3 3/4D2".to_notes
+      end
+
+      context 'neither part in score already' do
+        it 'should create both parts with given notes and add to score' do
+          s = Score::Timed.new
+          s.notes("A" => @notes_a, "B" => @notes_b)
+          expect(s.parts).to include("A")
+          expect(s.parts).to include("B")
+          expect(s.parts["A"].notes).to eq(@notes_a)
+          expect(s.parts["B"].notes).to eq(@notes_b)
+        end
+      end
+
+      context 'both parts in score already' do
+        it 'should add onto part notes' do
+          s = Score::Timed.new(parts: { 
+            "A" => Part.new(Dynamics::MP),
+            "B" => Part.new(Dynamics::MF)
+          })
+          s.notes("A" => @notes_a, "B" => @notes_b)
+          expect(s.parts["A"].notes).to eq(@notes_a)
+          expect(s.parts["B"].notes).to eq(@notes_b)
+        end
+      end
+
+      context 'one part in score already' do
+        it 'should create the other part with an initial rest and add to score' do
+          first_note_a = Note.whole(C2)
+          s = Score::Timed.new(parts: { 
+            "A" => Part.new(Dynamics::MP, notes: [ first_note_a ]),
+          })
+          s.notes("A" => @notes_a, "B" => @notes_b)
+          expect(s.parts["A"].notes).to eq([first_note_a] + @notes_a)
+          expect(s.parts["B"].notes).to eq([Note.whole] + @notes_b)
+        end
+      end
+
+      context 'given equal duration note sets' do
+        it 'should not raise DurationMismatchError' do
+          @equal_duration_note_sets.combination(2).each do |note_sets|
+            s = Score::Timed.new
+            expect { s.notes("A" => note_sets[0], "B" => note_sets[1]) }.to_not raise_error
+          end
+        end
+      end
+
+      context 'given different duration note sets' do
+        it 'should raise DurationMismatchError' do
+          note_set_a = "/4 /4 /8".to_notes
+          note_set_b = "/4 /4 /8 /16".to_notes
+          s = Score::Timed.new
+          expect { s.notes("A" => note_set_a, "B" => note_set_b) }.to raise_error(DurationMismatchError)
+        end
+      end
+    end
+  end
+end

data/spec/notation/conversion/score_conversion_spec.rb

@@ -31,106 +31,6 @@ describe Score::Tempo do
     )
   end
 
-  describe '#measure_offsets' do
-    before(:all){ @moffs = @score.measure_offsets }
-    
-    it 'should return an already-sorted array' do
-      @moffs.should eq @moffs.sort
-    end
-    
-    it 'should start with offset from start tempo/meter/dynamic' do
-      @moffs[0].should eq(0)
-    end
-    
-    it 'should include offsets from tempo changes' do
-      @score.tempo_changes.each do |moff,change|
-        @moffs.should include(moff)
-        @moffs.should include(moff + change.duration)
-      end
-    end
-    
-    it 'should include offsets from meter changes' do
-      @score.meter_changes.keys.each {|moff| @moffs.should include(moff) }
-    end
-    
-    it "should include offsets from each part's dynamic changes" do
-      @score.parts.values.each do |part|
-        part.dynamic_changes.each do |moff,change|
-          @moffs.should include(moff)
-          change.offsets(moff).each {|offset| @moffs.should include(offset) }
-        end
-      end
-    end
-    
-    it 'should include offsets from program segments' do
-      @score.program.each do |seg|
-        @moffs.should include(seg.first)
-        @moffs.should include(seg.last)
-      end
-    end
-  end
-  
-  describe '#measure_durations' do
-    before(:all){ @mdurs = @score.measure_durations }
-    
-    it 'should return a Hash' do
-      @mdurs.should be_a Hash
-    end
-    
-    context 'no meter change at offset 0' do
-      it 'should have size of meter_changes.size + 1' do
-        @mdurs.size.should eq(@score.meter_changes.size + 1)
-      end
-      
-      it 'should begin with offset 0' do
-        @mdurs.keys.min.should eq(0)
-      end
-      
-      it 'should map start meter to offset 0' do
-        @mdurs[0.to_r].should eq(@score.start_meter.measure_duration)
-      end
-    end
-    
-    context 'meter change at offset 0' do
-      before :all do
-        @change = Change::Immediate.new(THREE_FOUR)
-        @score2 = Score::Tempo.new(FOUR_FOUR, 120, meter_changes: { 0 => @change })
-        @mdurs2 = @score2.measure_durations
-      end
-  
-      it 'should have same size as meter changes' do
-        @mdurs2.size.should eq(@score2.meter_changes.size)
-      end
-      
-      it 'should begin with offset 0' do
-        @mdurs2.keys.min.should eq(0)
-      end
-      
-      it 'should begin with meter change at offset 0, instead of start meter' do
-        @mdurs2[0].should eq(@change.end_value.measure_duration)
-      end
-    end
-    
-    context 'no meter changes' do
-      before :all do
-        @score3 = Score::Tempo.new(FOUR_FOUR, 120)
-        @mdurs3 = @score3.measure_durations
-      end
-  
-      it 'should have size 1' do
-        @mdurs3.size.should eq(1)
-      end
-      
-      it 'should begin with offset 0' do
-        @mdurs3.keys.min.should eq(0)
-      end
-      
-      it 'should begin with start meter' do
-        @mdurs3[0.to_r].should eq(@score3.start_meter.measure_duration)
-      end
-    end
-  end
-  
   describe '#to_timed' do
     it 'should use ScoreConverter#convert_score' do
       nscore1 = @score.to_timed(200)

data/spec/notation/conversion/score_converter_spec.rb

@@ -25,7 +25,7 @@ describe ScoreConverter do
       parts.keys.sort.should eq(@score.parts.keys.sort)
     end
     
-    it 'should convert part dynamic change offsets from measure-based to note-based' do
+    it 'should convert part dynamic change offsets from note-based to time-based' do
       parts = ScoreConverter.new(@score,200).convert_parts
       parts.should have_key("simple")
       part = parts["simple"]
@@ -36,36 +36,36 @@ describe ScoreConverter do
       change.end_value.should eq(@changeB.end_value)
       change.duration.should eq(4)
       
-      #@score.start_meter = THREE_FOUR
-      #parts = ScoreConverter.new(@score,200).convert_parts
-      #parts.should have_key("simple")
-      #part = parts["simple"]
-      #part.dynamic_changes.keys.sort.should eq([Rational(3,4),Rational(9,4)])
-      #change = part.dynamic_changes[Rational(3,4)]
-      #change.end_value.should eq(@changeA.end_value)
-      #change.duration.should eq(0)
-      #change = part.dynamic_changes[Rational(9,4)]
-      #change.end_value.should eq(@changeB.end_value)
-      #change.duration.should eq(1.5)
+      @score.start_meter = THREE_FOUR
+      parts = ScoreConverter.new(@score,200).convert_parts
+      parts.should have_key("simple")
+      part = parts["simple"]
+      part.dynamic_changes.keys.sort.should eq([2,6])
+      change = part.dynamic_changes[2.0]
+      change.end_value.should eq(@changeA.end_value)
+      change.duration.should eq(0)
+      change = part.dynamic_changes[6.0]
+      change.end_value.should eq(@changeB.end_value)
+      change.duration.should eq(4)
     end
     
-    #context 'gradual changes with positive elapsed and/or remaining' do
-    #  it 'should change elapsed and remaining so they reflect note-based offsets' do
-    #    score = Score::Tempo.new(THREE_FOUR,120, parts: {
-    #      "abc" => Part.new(Dynamics::P, dynamic_changes: {
-    #          2 => Change::Gradual.linear(Dynamics::F,2,1,3),
-    #          7 => Change::Gradual.linear(Dynamics::F,1,4,5)
-    #      })
-    #    })
-    #    converter = ScoreConverter.new(score)
-    #    parts = converter.convert_parts
-    #    dcs = parts["abc"].dynamic_changes
-    #    
-    #    dcs.keys.should eq([Rational(6,4), Rational(21,4)])
-    #    dcs[Rational(3,2)].should eq(Change::Gradual.linear(Dynamics::F,Rational(6,4),Rational(3,4),Rational(9,4)))
-    #    dcs[Rational(21,4)].should eq(Change::Gradual.linear(Dynamics::F,Rational(3,4),Rational(12,4),Rational(15,4)))
-    #  end
-    #end
+    context 'gradual changes with positive elapsed and/or remaining' do
+     it 'should change elapsed and remaining so they reflect time-based offsets' do
+       score = Score::Tempo.new(THREE_FOUR,120, parts: {
+         "abc" => Part.new(Dynamics::P, dynamic_changes: {
+             2 => Change::Gradual.linear(Dynamics::F,2).to_trimmed(1, 3),
+             7 => Change::Gradual.linear(Dynamics::F,1).to_trimmed(4, 5)
+         })
+       })
+       converter = ScoreConverter.new(score, 200)
+       parts = converter.convert_parts
+       dcs = parts["abc"].dynamic_changes
+       
+       dcs.keys.should eq([4, 14])
+       dcs[4.0].should eq(Change::Gradual.linear(Dynamics::F,4).to_trimmed(2,6))
+       dcs[14.0].should eq(Change::Gradual.linear(Dynamics::F,2).to_trimmed(8,10))
+     end
+    end
   end
   
   describe '#convert_program' do
@@ -81,7 +81,7 @@ describe ScoreConverter do
       prog.size.should eq(@score.program.size)
     end
   
-    it 'should convert program segments offsets from measure-based to note-based' do
+    it 'should convert program segments offsets from note-based to time-based' do
       prog = ScoreConverter.new(@score,200).convert_program
       prog.size.should eq(2)
       prog[0].first.should eq(0)
@@ -93,9 +93,9 @@ describe ScoreConverter do
       prog = ScoreConverter.new(@score,200).convert_program
       prog.size.should eq(2)
       prog[0].first.should eq(0)
-      prog[0].last.should eq(6)
-      prog[1].first.should eq(3)
-      prog[1].last.should eq(7.5)
+      prog[0].last.should eq(8)
+      prog[1].first.should eq(4)
+      prog[1].last.should eq(10)
     end
   end
   

data/spec/notation/model/note_spec.rb

@@ -25,7 +25,7 @@ describe Note do
     
     it 'should assign :marks if given' do
       [
-        [], [BEGIN_SLUR, BEGIN_TRIPLET]
+        [], [BEGIN_SLUR], [END_SLUR]
       ].each do |marks|
         Note.quarter(marks: marks).marks.should eq(marks)
       end
@@ -131,7 +131,7 @@ describe Note do
           pitches,links = pitches_links_set
           if pitches.any?
             articulations.each do |art|
-              [[],[BEGIN_SLUR],[END_SLUR, BEGIN_TRIPLET]].each do |marks|
+              [[],[BEGIN_SLUR],[END_SLUR]].each do |marks|
                 notes.push Note.new(d, pitches, articulation: art, links: links, marks: marks)
               end
             end

data/spec/notation/model/score_spec.rb

@@ -64,32 +64,7 @@ describe Score do
       end
     end
   end
-  
-  describe '#max_part_duration' do
-    context 'no parts' do
-      it 'should return 0' do
-        Score.new.max_part_duration.should eq(0)
-      end
-    end
     
-    context 'one part' do
-      it 'should return the part duration' do
-        Score.new(parts: {"part1" => Part.new(Dynamics::PP,
-          notes: "/4 /4 /2 1".to_notes)
-        }).max_part_duration.should eq(2)
-      end
-    end
-
-    context 'two parts' do
-      it 'should return the part duration of the longer part' do
-        Score.new(parts: {"part1" => Part.new(Dynamics::PP,
-          notes: "/4 /4 /2 1".to_notes), "part2" => Part.new(Dynamics::MP,
-          notes: "4".to_notes)
-        }).max_part_duration.should eq(4)
-      end
-    end
-  end
-  
   describe '#valid?' do
     context 'non-Range objects' do
       it 'should return false' do
@@ -163,69 +138,26 @@ describe Score::Tempo do
     end
   end
   
-  describe '#measures_long' do
-    context 'with no meter changes' do
-      context 'with no parts' do
-        it 'should return 0' do
-          Score::Tempo.new(TWO_FOUR, 120).measures_long.should eq(0)
-        end
-      end
-
-      context 'with one part' do
-        it 'should return the duration of the part, in measures' do
-          Score::Tempo.new(TWO_FOUR, 120, parts: {
-            "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes)
-          }).measures_long.should eq(3.5)
-        end
-      end
-      
-      context 'with two parts' do
-        it 'should return the duration of the longest part, in measures' do
-          Score::Tempo.new(TWO_FOUR, 120, parts: {
-            "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes),
-            "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1".to_notes)
-          }).measures_long.should eq(4)
-        end
+  describe '#duration' do
+    context 'with no parts' do
+      it 'should return 0' do
+        Score::Tempo.new(TWO_FOUR, 120).duration.should eq(0)
       end
     end
-    
-    context 'with meter changes' do
-      it 'should return the duration of the longest part, in measures' do
-        Score::Tempo.new(TWO_FOUR, 120,
-          meter_changes: {
-            2 => Change::Immediate.new(FOUR_FOUR),
-          },
-          parts: {
-            "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes),
-            "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1".to_notes)
-          }
-        ).measures_long.should eq(3)
-        
-        Score::Tempo.new(TWO_FOUR, 120,
-          meter_changes: {
-            2 => Change::Immediate.new(FOUR_FOUR),
-            4 => Change::Immediate.new(SIX_EIGHT),
-          },
-          parts: {
-            "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes),
-            "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1 /2".to_notes)
-          }
-        ).measures_long.should eq(3.5)
+    context 'with one part' do
+      it 'should return the duration of the part, in notes' do
+        Score::Tempo.new(TWO_FOUR, 120, parts: {
+          "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes)
+        }).duration.should eq(1.75)
       end
     end
     
-    context 'given specific note duration' do
-      it 'should change the given note duration to measures' do
-        score = Score::Tempo.new(TWO_FOUR, 120,
-            meter_changes: {
-              2 => Change::Immediate.new(FOUR_FOUR),
-              4 => Change::Immediate.new(SIX_EIGHT)
-        })
-        
-        { 1 => 2, 1.5 => 2.5, 2 => 3, 3 => 4, 3.75 => 5
-        }.each do |note_dur, meas_dur|
-          score.measures_long(note_dur).should eq(meas_dur)
-        end
+    context 'with two parts' do
+      it 'should return the duration of the longest part, in notes' do
+        Score::Tempo.new(TWO_FOUR, 120, parts: {
+          "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes),
+          "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1".to_notes)
+        }).duration.should eq(2)
       end
     end
   end
@@ -258,8 +190,6 @@ describe Score::Tempo do
         :meter_changes => { 1 => Change::Immediate.new(5) } ],
       'non-immediate meter change' => [ FOUR_FOUR, 120,
         :meter_changes => { 1 => Change::Gradual.linear(TWO_FOUR,1) } ],
-      'non-integer meter change offset' => [ FOUR_FOUR, 120,
-        :meter_changes => { 1.1 => Change::Immediate.new(TWO_FOUR) } ],
       'invalid part' => [ FOUR_FOUR, 120, :parts => { "piano" => Part.new(-0.1) }],
       'invalid program' => [ FOUR_FOUR, 120, :program => [2..0] ],
     }.each do |context_str,args|
@@ -314,12 +244,12 @@ describe Score::Timed do
     end
   end
   
-  describe '#seconds_long' do
+  describe '#duration' do
     it 'should return the duration of the longest part' do
       Score::Timed.new(parts: {
         "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes),
         "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1".to_notes)
-      }).seconds_long.should eq(2)
+      }).duration.should eq(2)
     end
   end