musicality 0.8.0 → 0.9.0

data/lib/musicality/notation/packing/part_packing.rb

@@ -1,31 +0,0 @@
-module Musicality
-
-class Part
-  def pack
-    packed_notes = notes.map {|n| n.to_s }.join(" ")
-    packed_dcs = Hash[ dynamic_changes.map do |offset,change|
-      [ offset, change.pack ]
-    end ]
-      
-    {
-      'notes' => packed_notes,
-      'start_dynamic' => start_dynamic,
-      'dynamic_changes' => packed_dcs
-    }
-  end
-  
-  def self.unpack packing
-    unpacked_notes = Note.split_parse(packing["notes"])
-    unpacked_dcs = Hash[ packing["dynamic_changes"].map do |offset,change|
-      [ offset,Change.unpack(change) ]
-    end ]
-    
-    new(
-      packing["start_dynamic"],
-      notes: unpacked_notes,
-      dynamic_changes: unpacked_dcs
-    )
-  end
-end
-
-end

data/lib/musicality/notation/packing/score_packing.rb

@@ -1,123 +0,0 @@
-module Musicality
-
-class Score
-  class Timed < Score
-    def pack
-      pack_common
-    end
-    
-    def self.unpack packing
-      new(**Score.unpack_common(packing))
-    end
-  end
-  
-  class TempoBased < Score
-    def pack
-      pack_common.merge("start_tempo" => @start_tempo,
-        "tempo_changes" => pack_tempo_changes)
-    end
-    
-    def pack_tempo_changes
-      Hash[ tempo_changes.map do |offset,change|
-        [offset,change.pack]
-      end ]
-    end
-
-    def self.unpack_tempo_changes packing
-      Hash[ packing["tempo_changes"].map do |k,v|
-        [k, Change.unpack(v) ]
-      end ]
-    end
-
-    def self.unpack packing
-      unpacked_tcs = Hash[ packing["tempo_changes"].map do |k,v|
-        [k, Change.unpack(v) ]
-      end ]
-
-      Score.unpack_common(packing)
-      new(packing["start_tempo"],
-        tempo_changes: unpacked_tcs,
-        **unpacked)
-    end
-  end
-  
-  class Unmeasured < TempoBased
-    def self.unpack packing
-      new(packing["start_tempo"],
-        tempo_changes: unpack_tempo_changes(packing),
-        **Score.unpack_common(packing))
-    end
-  end
-  
-  class Measured < TempoBased
-    def pack
-      return super().merge("start_meter" => pack_start_meter,
-        "meter_changes" => pack_meter_changes)
-    end
-
-    def pack_meter_changes
-      Hash[ meter_changes.map do |off,change|
-        [off,change.pack(:with => :to_s)]
-      end ]
-    end
-
-    def pack_start_meter
-      start_meter.to_s
-    end
-    
-    def self.unpack_meter_changes packing
-      Hash[ packing["meter_changes"].map do |off,p|
-         [off, Change.unpack(p, :with => :to_meter) ]
-      end ]
-    end
-
-    def self.unpack_start_meter packing
-      Meter.parse(packing["start_meter"])
-    end
-
-    def self.unpack packing
-      new(unpack_start_meter(packing), packing["start_tempo"],
-        tempo_changes: unpack_tempo_changes(packing),
-        meter_changes: unpack_meter_changes(packing),
-        **Score.unpack_common(packing))
-    end
-  end
-  
-  def self.unpack packing
-    type = const_get(packing["type"])
-    type.unpack(packing)
-  end
-  
-  private
-  
-  def pack_common
-    packed_parts = Hash[
-      @parts.map do |name,part|
-        [ name, part.pack ]
-      end
-    ]
-    packed_prog = @program.map {|seg| seg.to_s }
-    
-    { "type" => self.class.to_s.split("::")[-1],
-      "program" => packed_prog,
-      "parts" => packed_parts,
-      "title" => @title,
-      "composer" => @composer
-    }
-  end
-  
-  def self.unpack_common packing
-    unpacked_parts = Hash[ packing["parts"].map do |name,packed|
-      [name, Part.unpack(packed)]
-    end ]
-    unpacked_prog = packing["program"].map {|str| Segment.parse(str) }
-    
-    { :program => unpacked_prog,
-      :parts => unpacked_parts,
-      :title => packing["title"],
-      :composer => packing["composer"]
-    }
-  end    
-end
-
-end

data/lib/musicality/performance/model/note_attacks.rb

@@ -1,19 +0,0 @@
-module Musicality
-
-require 'singleton'
-class AccentedAttack
-  include Singleton
-  
-  def accented?; return true; end
-end
-
-class UnaccentedAttack
-  include Singleton
-  
-  def accented?; return false; end
-end
-
-ACCENTED = AccentedAttack.instance
-UNACCENTED = UnaccentedAttack.instance
-
-end

data/lib/musicality/performance/util/note_linker.rb

@@ -1,28 +0,0 @@
-module Musicality
-
-class NoteLinker
-  def self.find_unlinked_pitches note
-    linked = Set.new(note.pitches) & note.links.keys
-    (Set.new(note.pitches) - linked).to_a
-  end
-  
-  def self.find_untargeted_pitches note, next_note
-    linked = Set.new(note.pitches) & note.links.keys
-    targeted = Set.new(linked.map {|p| note.links[p].target_pitch })
-    (Set.new(next_note.pitches) - targeted).to_a
-  end
-  
-  def self.figure_links note, next_note
-    unlinked = find_unlinked_pitches(note)
-    untargeted = find_untargeted_pitches(note, next_note)
-    Optimization.linking(unlinked, untargeted)
-  end
-  
-  def self.fully_link note, next_note, link_class
-    figure_links(note,next_note).each do |pitch,tgt_pitch|
-      note.links[pitch] = link_class.new(tgt_pitch)
-    end
-  end  
-end
-
-end

data/spec/notation/packing/change_packing_spec.rb

@@ -1,304 +0,0 @@
-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)
-      @p = @c.pack
-    end
-    
-    it 'should return a Hash' do
-      @p.should be_a Hash
-    end
-    
-    it 'should have "type" and "end_value" keys' do
-      @p.should have_key("type")
-      @p.should have_key("end_value")
-    end
-    
-    it 'should assign "Immediate" to "type" key' do
-      @p["type"].should eq("Immediate")
-    end
-    
-    it 'should assign end_value to "end_value" key' do
-      @p["end_value"].should eq(@c.end_value)
-    end
-    
-    context 'given :with method' do
-      it 'should send the :with method to end_value' do
-        p = @c.pack(:with => :to_s)
-        p["end_value"].should be_a String
-        p["end_value"].to_f.should eq(@c.end_value)
-      end
-    end
-  end
-end
-
-describe Change::Gradual do
-  describe '#pack' do
-    before :all do
-      @c = Change::Gradual.linear(200,2.5)
-      @p = @c.pack
-    end
-    
-    it 'should return a Hash' do
-      @p.should be_a Hash
-    end
-    
-    it 'should have "type", "end_value", "duration", "transition", and keys' do
-      @p.keys.sort.should eq(["duration","end_value","transition","type"])
-    end
-    
-    it 'should assign "Gradual" to "type" key' do
-      @p["type"].should eq("Gradual")
-    end
-    
-    it 'should assign end_value to "end_value" key' do
-      @p["end_value"].should eq(@c.end_value)
-    end
-    
-    it 'should assign duration to "duration" key' do
-      @p["duration"].should eq(@c.duration)
-    end
-    
-    it 'should assign start value to "start_value" key' do
-      @p["start_value"].should eq(@c.start_value)
-    end
-
-    it 'should assign transition to "transition" key' do
-      @p["transition"].should eq(@c.transition)
-    end
-    
-    context 'given :with method' do
-      it 'should send the :with method to end_value' do
-        p = @c.pack(:with => :to_s)
-        p["end_value"].should be_a String
-        p["end_value"].to_f.should eq(@c.end_value)
-      end
-    end
-    
-    context 'given start value' do
-      it 'should assign start_value to "start_value" ' do
-        c = Change::Gradual.linear(200,2.5,start_value: 20)
-        p = c.pack
-        p.should have_key("start_value")
-        p["start_value"].should eq(c.start_value)
-      end
-      
-      context 'given :with method' do
-        it 'should send the :with method to end_value' do
-          c = Change::Gradual.linear(200,2.5,start_value: 20)
-          p = c.pack(:with => :to_s)
-          p["start_value"].should be_a String
-          p["start_value"].to_f.should eq(c.start_value)
-        end
-      end
-    end
-  end
-end
-
-describe Change::Gradual::Trimmed do
-  describe '#pack' do
-    before :all do
-      @c = Change::Gradual::Trimmed.linear(200,2.5,preceding:1,remaining:0.5)
-      @p = @c.pack
-    end
-    
-    it 'should return a Hash' do
-      @p.should be_a Hash
-    end
-    
-    it 'should have "type", "end_value", "duration", "transition", "preceding", "remaining" keys' do
-      @p.keys.sort.should eq(["duration","end_value","preceding","remaining","transition","type"])
-    end
-    
-    it 'should assign "Gradual::Trimmed" to "type" key' do
-      @p["type"].should eq("Gradual::Trimmed")
-    end
-    
-    it 'should assign end_value to "end_value" key' do
-      @p["end_value"].should eq(@c.end_value)
-    end
-    
-    it 'should assign duration to "duration" key' do
-      @p["duration"].should eq(@c.duration)
-    end
-    
-    it 'should assign transition to "transition" key' do
-      @p["transition"].should eq(@c.transition)
-    end
-
-    it 'should assign preceding to "preceding" key' do
-      @p["preceding"].should eq(@c.preceding)
-    end
-    
-    it 'should assign remaining to "remaining" key' do
-      @p["remaining"].should eq(@c.remaining)
-    end
-    
-    context 'given :with method' do
-      it 'should send the :with method to end_value' do
-        p = @c.pack(:with => :to_s)
-        p["end_value"].should be_a String
-        p["end_value"].to_f.should eq(@c.end_value)
-      end
-    end
-    
-    context 'given start value' do
-      it 'should assign start_value to "start_value" ' do
-        c = Change::Gradual.linear(200,2.5,start_value: 20).trim(0.5,0.5)
-        p = c.pack
-        p.should have_key("start_value")
-        p["start_value"].should eq(c.start_value)
-      end
-      
-      context 'given :with method' do
-      it 'should send the :with method to end_value' do
-        c = Change::Gradual.linear(200,2.5,start_value: 20).trim(0.5,0.5)
-        p = c.pack(:with => :to_s)
-        p["start_value"].should be_a String
-        p["start_value"].to_f.should eq(c.start_value)
-        end
-      end
-    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 end_value' do
-        @c2.end_value.should eq @c.end_value
-      end
-      
-      context 'pack/unpack using :with method' do
-        it 'should use given :with method to convert end_value' do
-          c = Change::Immediate.new(0.5)
-          h = c.pack(:with => :to_s)
-          c2 = Change.unpack(h)
-          c2.end_value.should be_a String
-          c3 = Change.unpack(h, :with => :to_f)
-          c3.end_value.should be_a Float
-        end
-      end
-    end
-    
-    context 'given a packed gradual change' do
-      before :all do
-        @c = Change::Gradual.sigmoid(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 unpack the end_value' do
-        @c2.end_value.should eq @c.end_value
-      end
-      
-      it 'should unpack the change duration' do
-        @c2.duration.should eq @c.duration
-      end
-
-      it 'should unpack the change transition' do
-        @c2.transition.should eq @c.transition
-      end
-      
-      it 'should unpack the change start_value' do
-        @c2.start_value.should eq @c.start_value
-      end
-      
-      context 'pack/unpack using :with method' do
-        it 'should use given :with method to convert end_value' do
-          c = Change::Gradual.linear(0.5,2)
-          h = c.pack(:with => :to_s)
-          c2 = Change.unpack(h)
-          c2.end_value.should be_a String
-          c3 = Change.unpack(h, :with => :to_f)
-          c3.end_value.should be_a Float
-        end
-        
-        context 'when change start_value is not nil' do
-          it 'should use given :with method to convert start_value' do
-            c = Change::Gradual.linear(0.5,2,start_value: 0.1)
-            h = c.pack(:with => :to_s)
-            c2 = Change.unpack(h)
-            c2.start_value.should be_a String
-            c3 = Change.unpack(h, :with => :to_f)
-            c3.start_value.should be_a Float
-          end
-        end
-      end
-    end
-    
-    context 'given a packed gradual (trimmed) change' do
-      before :all do
-        @c = Change::Gradual::Trimmed.sigmoid(0.3,1.5,preceding:0.1,remaining:0.1)
-        @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 end_value' do
-        @c2.end_value.should eq @c.end_value
-      end
-      
-      it 'should successfully unpack the change duration' do
-        @c2.duration.should eq @c.duration
-      end
-
-      it 'should successfully unpack the change transition' do
-        @c2.transition.should eq @c.transition
-      end
-      
-      it 'should unpack the change start_value' do
-        @c2.start_value.should eq @c.start_value
-      end
-      
-      it 'should successfully unpack the change preceding' do
-        @c2.preceding.should eq @c.preceding
-      end
-      
-      it 'should successfully unpack the change remaining' do
-        @c2.remaining.should eq @c.remaining
-      end
-      
-      context 'pack/unpack using :with method' do
-        it 'should use given :with method to convert end_value' do
-          c = Change::Gradual.linear(0.5,2).trim(0.4,0.3)
-          h = c.pack(:with => :to_s)
-          c2 = Change.unpack(h)
-          c2.end_value.should be_a String
-          c3 = Change.unpack(h, :with => :to_f)
-          c3.end_value.should be_a Float
-        end
-        
-        context 'when change start_value is not nil' do
-          it 'should use given :with method to convert start_value' do
-            c = Change::Gradual.linear(0.5,2,start_value: 0.1).trim(0.4,0.3)
-            h = c.pack(:with => :to_s)
-            c2 = Change.unpack(h)
-            c2.start_value.should be_a String
-            c3 = Change.unpack(h, :with => :to_f)
-            c3.start_value.should be_a Float
-          end
-        end
-      end
-    end    
-  end
-end