musicality 0.1.0

data/lib/musicality/notation/model/pitches.rb

@@ -0,0 +1,21 @@
+module Musicality
+
+module Pitches
+  # Define pitch objects for octaves octave 0 through 9
+  {
+    :Bb => 10, :B => 11,
+    :Cb => 11, :C => 0,
+    :Db => 1, :D => 2,
+    :Eb => 3, :E => 4,
+    :Fb => 4, :F => 5,
+    :Gb => 6, :G => 7,
+    :Ab => 8, :A => 9,
+  }.each do |sym,pc|
+    (0..9).each do |octave|
+      obj = Pitch.new octave: octave, semitone: pc
+      Pitches.const_set(:"#{sym}#{octave}",obj)
+    end
+  end
+end
+
+end

data/lib/musicality/notation/model/program.rb

@@ -0,0 +1,53 @@
+module Musicality
+
+# Program defines markers (by starting note offset) and subprograms (list which markers are played).
+#
+# @author James Tunnell
+#
+class Program
+  include Validatable
+  
+  attr_accessor :segments
+  
+  def initialize segments = []
+    @segments = segments
+  end
+
+  def check_methods
+    [:ensure_increasing_segments, :ensure_nonnegative_segments]
+  end
+  
+  # @return [Float] the sum of all program segment lengths
+  def length
+    segments.inject(0.0) { |length, segment| length + (segment.last - segment.first) }
+  end
+  
+  def == other
+    return other.respond_to?(:segments) && @segments == other.segments
+  end
+
+  def include? offset
+    @segments.each do |segment|
+      if segment.include?(offset)
+        return true
+      end
+    end
+    return false
+  end
+  
+  def ensure_increasing_segments
+    non_increasing = @segments.select {|seg| seg.first >= seg.last }
+    if non_increasing.any?
+      raise NonIncreasingError, "Non-increasing segments found #{non_increasing}"
+    end
+  end
+  
+  def ensure_nonnegative_segments
+    negative = @segments.select {|seg| seg.first < 0 || seg.last < 0 }
+    if negative.any?
+      raise NegativeError, "Segments #{negative} have negative values"
+    end
+  end
+end
+
+end

data/lib/musicality/notation/model/score.rb

@@ -0,0 +1,132 @@
+module Musicality
+
+class Score
+  include Validatable
+  attr_accessor :parts, :program
+  
+  def initialize parts: {}, program: Program.new
+    @parts = parts
+    @program = program
+    yield(self) if block_given?
+  end
+
+  def validatables
+    [ @program ] + @parts.values
+  end
+  
+  def clone
+    Marshal.load(Marshal.dump(self))
+  end
+  
+  def ==(other)
+    return @parts == other.parts && @program == other.program
+  end
+  
+  def duration
+    @parts.map {|p| p.duration }.max
+  end
+  
+  def collated?
+    @program.segments.size == 1 && @program.segments[0].first == 0
+  end
+  
+  class Timed < Score
+  end
+  
+  class TempoBased < Score
+    attr_accessor :start_tempo, :tempo_changes
+
+    def initialize start_tempo, tempo_changes: {}, parts: {}, program: Program.new
+      @start_tempo = start_tempo
+      @tempo_changes = tempo_changes
+      super(parts: parts, program: program)
+      
+      yield(self) if block_given?
+    end
+    
+    def check_methods
+      [:check_start_tempo, :check_tempo_changes]
+    end
+  
+    def ==(other)
+      return super(other) && @start_tempo == other.start_tempo &&
+      @tempo_changes == other.tempo_changes
+    end
+    
+    def check_start_tempo
+      if @start_tempo <= 0
+        raise NonPositiveError, "start tempo (#{@start_tempo}) is not positive"
+      end
+    end
+    
+    def check_tempo_changes
+      badvalues = @tempo_changes.select {|k,v| v.value <= 0 }
+      if badvalues.any?
+        raise NonPositiveError, "tempo changes (#{badvalues}) are not positive"
+      end    
+    end
+  end
+  
+  # Tempo-based score without meter, bar lines, or fixed pulse (beat).
+  # Offsets are note-based, and tempo values are in quarter-notes-per-minute.
+  class Unmeasured < Score::TempoBased
+  end
+  
+  # Tempo-based score with meter, bar lines, and a fixed pulse (beat).
+  # Offsets are measure-based, and tempo values are in beats-per-minute.
+  class Measured < Score::TempoBased
+    attr_accessor :start_meter, :meter_changes
+    
+    def initialize start_meter, start_tempo, meter_changes: {}, tempo_changes: {}, parts: {}, program: Program.new
+      @start_meter = start_meter
+      @meter_changes = meter_changes
+      
+      super(start_tempo, tempo_changes: tempo_changes,
+            program: program, parts: parts)
+      yield(self) if block_given?
+    end
+    
+    def check_methods
+      super() + [:check_startmeter_type, :check_meterchange_types,
+                 :check_meterchange_durs, :check_meterchange_offsets]
+    end
+    
+    def validatables
+      super() + [ @start_meter ] + @meter_changes.values.map {|v| v.value}
+    end
+    
+    def check_startmeter_type
+      unless @start_meter.is_a? Meter
+        raise TypeError, "start meter #{@start_meter} is not a Meter object"
+      end
+    end
+    
+    def check_meterchange_types
+      badtypes = @meter_changes.select {|k,v| !v.value.is_a?(Meter) }
+      if badtypes.any?
+        raise TypeError, "meter change values #{nonmeter_values} are not Meter objects"
+      end
+    end
+    
+    def check_meterchange_offsets
+      badoffsets = @meter_changes.select {|k,v| k != k.to_i }
+      if badoffsets.any?
+        raise NonIntegerError, "meter changes #{badoffsets} have non-integer offsets"
+      end
+    end
+    
+    def check_meterchange_durs
+      nonzero_duration = @meter_changes.select {|k,v| !v.is_a?(Change::Immediate) }
+      if nonzero_duration.any?
+        raise NonZeroError, "meter changes #{nonzero_duration} are not immediate"
+      end
+    end
+    
+    def ==(other)
+      return super(other) && @start_meter == other.start_meter &&
+        @meter_changes == other.meter_changes
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,46 @@
+module Musicality
+
+class Change
+  class Immediate < Change
+    def pack
+      pack_common
+    end
+    
+    def self.unpack packing
+      new(packing["value"])
+    end
+  end
+  
+  class Gradual < Change
+    def pack
+      packing = pack_common.merge("impending" => @impending)
+      unless @remaining == 0
+        packing["remaining"] = @remaining
+      end
+      unless @elapsed == 0
+        packing["elapsed"] = @elapsed
+      end
+      return packing
+    end
+    
+    def self.unpack packing
+      elapsed = packing["elapsed"] || 0
+      remaining = packing["remaining"] || 0
+      new(packing["value"], packing["impending"], elapsed, remaining)
+    end
+  end
+
+  def self.unpack packing
+    type = const_get(packing["type"])
+    type.unpack(packing)
+  end
+  
+  private
+  
+  def pack_common
+    { "type" => self.class.to_s.split("::")[-1],
+      "value" => @value }
+  end
+end
+
+end

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

@@ -0,0 +1,31 @@
+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/program_packing.rb

@@ -0,0 +1,16 @@
+module Musicality
+
+class Program
+  def pack
+    @segments.map do |seg|
+      seg.to_s
+    end
+  end
+  
+  def self.unpack packing
+    segments = packing.map {|str| Segment.parse(str) }
+    new segments
+  end
+end
+
+end

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

@@ -0,0 +1,108 @@
+module Musicality
+
+class Score
+  class Timed < Score
+    def pack
+      pack_common
+    end
+    
+    def self.unpack packing
+      score = Score.unpack_common(packing)
+      new(parts: score.parts, program: score.program)
+    end
+  end
+  
+  class TempoBased < Score
+    def pack
+      packed_tcs = Hash[ tempo_changes.map do |offset,change|
+        [offset,change.pack]
+      end ]
+      
+      pack_common.merge("start_tempo" => @start_tempo,
+        "tempo_changes" => packed_tcs)
+    end
+    
+    def self.unpack packing
+      score = Score.unpack_common(packing)
+      
+      unpacked_tcs = Hash[ packing["tempo_changes"].map do |k,v|
+        [k, Change.unpack(v) ]
+      end ]
+      
+      new(packing["start_tempo"],
+        tempo_changes: unpacked_tcs,
+        program: score.program,
+        parts: score.parts
+      )
+    end    
+  end
+  
+  class Unmeasured < TempoBased
+    def pack
+      super()
+    end
+    
+    def self.unpack packing
+      score = superclass.unpack(packing)
+      new(score.start_tempo, program: score.program,
+        tempo_changes: score.tempo_changes, parts: score.parts)
+    end
+  end
+  
+  class Measured < TempoBased
+    def pack
+      return super().merge("start_meter" => start_meter.to_s,
+        "meter_changes" => Hash[ meter_changes.map do |off,change|
+          [off,change.pack.merge("value" => change.value.to_s)]
+        end ]
+      )
+    end
+    
+    def self.unpack packing
+      score = superclass.unpack(packing)
+      unpacked_start_meter = Meter.parse(packing["start_meter"])
+      unpacked_mcs = Hash[ packing["meter_changes"].map do |off,p|
+        [off, Change.unpack(p.merge("value" => Meter.parse(p["value"]))) ]
+      end ]
+      
+      new(unpacked_start_meter, score.start_tempo,
+          parts: score.parts, program: score.program,
+          meter_changes: unpacked_mcs, tempo_changes: score.tempo_changes)
+    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.pack
+    
+    { "type" => self.class.to_s.split("::")[-1],
+      "program" => packed_prog,
+      "parts" => packed_parts,
+    }
+  end
+  
+  def self.unpack_common packing
+    unpacked_parts = Hash[ packing["parts"].map do |name,packed|
+      [name, Part.unpack(packed)]
+    end ]
+    
+    unpacked_prog = Program.unpack packing["program"]
+    
+    new(program: unpacked_prog,
+      parts: unpacked_parts
+    )
+  end    
+end
+
+end

data/lib/musicality/notation/parsing/articulation_parsing.rb

@@ -0,0 +1,264 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module Musicality
+module Parsing
+
+module Articulation
+  include Treetop::Runtime
+
+  def root
+    @root ||= :articulation
+  end
+
+  def _nt_articulation
+    start_index = index
+    if node_cache[:articulation].has_key?(index)
+      cached = node_cache[:articulation][index]
+      if cached
+        node_cache[:articulation][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_slur
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_legato
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        r3 = _nt_tenuto
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          r4 = _nt_portato
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            r5 = _nt_staccato
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+            else
+              r6 = _nt_staccatissimo
+              if r6
+                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+                r0 = r6
+              else
+                @index = i0
+                r0 = nil
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:articulation][start_index] = r0
+
+    r0
+  end
+
+  module Slur0
+    def to_articulation
+      Musicality::Articulations::SLUR
+    end
+  end
+
+  def _nt_slur
+    start_index = index
+    if node_cache[:slur].has_key?(index)
+      cached = node_cache[:slur][index]
+      if cached
+        node_cache[:slur][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if (match_len = has_terminal?("=", false, index))
+      r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      r0.extend(Slur0)
+      @index += match_len
+    else
+      terminal_parse_failure("=")
+      r0 = nil
+    end
+
+    node_cache[:slur][start_index] = r0
+
+    r0
+  end
+
+  module Legato0
+    def to_articulation
+      Musicality::Articulations::LEGATO
+    end
+  end
+
+  def _nt_legato
+    start_index = index
+    if node_cache[:legato].has_key?(index)
+      cached = node_cache[:legato][index]
+      if cached
+        node_cache[:legato][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if (match_len = has_terminal?("|", false, index))
+      r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      r0.extend(Legato0)
+      @index += match_len
+    else
+      terminal_parse_failure("|")
+      r0 = nil
+    end
+
+    node_cache[:legato][start_index] = r0
+
+    r0
+  end
+
+  module Tenuto0
+    def to_articulation
+      Musicality::Articulations::TENUTO
+    end
+  end
+
+  def _nt_tenuto
+    start_index = index
+    if node_cache[:tenuto].has_key?(index)
+      cached = node_cache[:tenuto][index]
+      if cached
+        node_cache[:tenuto][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if (match_len = has_terminal?("_", false, index))
+      r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      r0.extend(Tenuto0)
+      @index += match_len
+    else
+      terminal_parse_failure("_")
+      r0 = nil
+    end
+
+    node_cache[:tenuto][start_index] = r0
+
+    r0
+  end
+
+  module Portato0
+    def to_articulation
+      Musicality::Articulations::PORTATO
+    end
+  end
+
+  def _nt_portato
+    start_index = index
+    if node_cache[:portato].has_key?(index)
+      cached = node_cache[:portato][index]
+      if cached
+        node_cache[:portato][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if (match_len = has_terminal?("%", false, index))
+      r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      r0.extend(Portato0)
+      @index += match_len
+    else
+      terminal_parse_failure("%")
+      r0 = nil
+    end
+
+    node_cache[:portato][start_index] = r0
+
+    r0
+  end
+
+  module Staccato0
+    def to_articulation
+      Musicality::Articulations::STACCATO
+    end
+  end
+
+  def _nt_staccato
+    start_index = index
+    if node_cache[:staccato].has_key?(index)
+      cached = node_cache[:staccato][index]
+      if cached
+        node_cache[:staccato][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if (match_len = has_terminal?(".", false, index))
+      r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      r0.extend(Staccato0)
+      @index += match_len
+    else
+      terminal_parse_failure(".")
+      r0 = nil
+    end
+
+    node_cache[:staccato][start_index] = r0
+
+    r0
+  end
+
+  module Staccatissimo0
+    def to_articulation
+      Musicality::Articulations::STACCATISSIMO
+    end
+  end
+
+  def _nt_staccatissimo
+    start_index = index
+    if node_cache[:staccatissimo].has_key?(index)
+      cached = node_cache[:staccatissimo][index]
+      if cached
+        node_cache[:staccatissimo][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if (match_len = has_terminal?("'", false, index))
+      r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      r0.extend(Staccatissimo0)
+      @index += match_len
+    else
+      terminal_parse_failure("'")
+      r0 = nil
+    end
+
+    node_cache[:staccatissimo][start_index] = r0
+
+    r0
+  end
+
+end
+
+class ArticulationParser < Treetop::Runtime::CompiledParser
+  include Articulation
+end
+
+
+end
+end