musicality 0.11.1 → 0.12.0

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

@@ -2,27 +2,28 @@ module Musicality
 
 class Key
   include Packable
-  
+
   FLAT = :flat
   SHARP = :sharp
-  ACCIDENTAL_TYPES = [FLAT, SHARP]
-  
+  NONE = :none
+  ACCIDENTAL_TYPES = [FLAT, SHARP, NONE]
+
   MAJOR = :major
   MINOR = :minor
   TRIAD_TYPES = [MAJOR, MINOR]
-  
-  TONICS = {
+
+  TONIC_PCS = {
     MAJOR => {
       FLAT => [PitchClasses::F, PitchClasses::Bb, PitchClasses::Eb,
-        PitchClasses::Ab, PitchClasses::Db, PitchClasses::Gb, PitchClasses::Cb],
+        PitchClasses::Ab, PitchClasses::Db, PitchClasses::Gb],
       SHARP => [PitchClasses::G,PitchClasses::D,PitchClasses::A,
-        PitchClasses::E,PitchClasses::B,PitchClasses::Fs,PitchClasses::Cs]
+        PitchClasses::E,PitchClasses::B]
     },
     MINOR => {
       FLAT => [PitchClasses::D,PitchClasses::G,PitchClasses::C,
-        PitchClasses::F,PitchClasses::Bb,PitchClasses::Eb,PitchClasses::Ab],
+        PitchClasses::F,PitchClasses::Bb,PitchClasses::Eb],
       SHARP => [PitchClasses::E,PitchClasses::B,PitchClasses::Fs,
-        PitchClasses::Cs,PitchClasses::Gs,PitchClasses::Ds,PitchClasses::As]
+        PitchClasses::Cs,PitchClasses::Gs]
     }
   }
 
@@ -33,105 +34,55 @@ class Key
       PitchClasses::Ds,PitchClasses::As,PitchClasses::Es,PitchClasses::Bs]
   }
 
-  attr_reader :tonic_pc, :triad, :accidental_pref
-  
-  def initialize tonic_pc, triad: MAJOR, accidental_pref: FLAT
-    self.tonic_pc = tonic_pc
-    self.triad = triad
-    self.accidental_pref = accidental_pref
-  end
-  
-  def self.major_flat tonic_pc
-    Key.new(tonic_pc, triad: MAJOR, accidental_pref: FLAT)
-  end
-  
-  def self.major_sharp tonic_pc
-    Key.new(tonic_pc, triad: MAJOR, accidental_pref: SHARP)
-  end
-  
-  def self.minor_flat tonic_pc
-    Key.new(tonic_pc, triad: MINOR, accidental_pref: FLAT)
-  end
-  
-  def self.minor_sharp tonic_pc
-    Key.new(tonic_pc, triad: MINOR, accidental_pref: SHARP)
-  end
-  
-  def major?; @triad == MAJOR; end
-  def minor?; @triad == MINOR; end
-  
-  def flat?; accidental_type == FLAT; end
-  def sharp?; accidental_type == SHARP; end
-  
-  def accidental_free?
-    (major? && @tonic_pc == PitchClasses::C) || (minor? && @tonic_pc == PitchClasses::A)
-  end
+  attr_reader :tonic_pc, :triad_type, :accidentals, :accidental_type
 
-  def triad= triad
-    if triad != @triad
-      unless TRIAD_TYPES.include? triad
-        raise ArgumentError, "Triad type #{triad} is not supported"
+  def initialize tonic_pc, triad_type: MAJOR
+    raise ArgumentError, "Unknown triad type #{triad_type}" unless TRIAD_TYPES.include?(triad_type)
+    @triad_type = triad_type
+    @tonic_pc = PitchClass.from_i(tonic_pc)
+
+    if (@triad_type == MAJOR && @tonic_pc == PitchClasses::C) ||
+        (@triad_type == MINOR && @tonic_pc == PitchClasses::A)
+      @accidentals = []
+      @accidental_type = NONE
+    else
+      if TONIC_PCS[@triad_type][FLAT].include?(@tonic_pc)
+        @accidental_type = FLAT
+      elsif TONIC_PCS[@triad_type][SHARP].include?(@tonic_pc)
+        @accidental_type = SHARP
+      else
+        raise ArgumentError, "unknown tonic PC #{@tonic_pc}"
       end
-      @triad = triad
-      reset_accidentals
+      i = TONIC_PCS[@triad_type][@accidental_type].index(@tonic_pc)
+      @accidentals = ACCIDENTALS[@accidental_type][0..i]
     end
   end
 
-  def accidental_pref= accidental_pref
-    if accidental_pref != @accidental_pref
-      unless ACCIDENTAL_TYPES.include? accidental_pref
-        raise ArgumentError, "Accidental type #{accidental_pref} is not supported"
-      end
-      @accidental_pref = accidental_pref
-      reset_accidentals
-    end
+  def self.major tonic_pc
+    Key.new(tonic_pc, triad_type: MAJOR)
   end
 
-  def tonic_pc= tonic_pc
-    if tonic_pc != @tonic_pc
-      @tonic_pc = PitchClass.from_i(tonic_pc)
-      reset_accidentals
-    end
+  def self.minor tonic_pc
+    Key.new(tonic_pc, triad_type: MINOR)
   end
-  
+
+  def major?; @triad_type == MAJOR; end
+  def minor?; @triad_type == MINOR; end
+
+  def flat?; @accidental_type == FLAT; end
+  def sharp?; @accidental_type == SHARP; end
+
   def ==(other)
-    return @tonic_pc == other.tonic_pc && @triad == other.triad && 
-      @accidental_pref == other.accidental_pref
+    return @tonic_pc == other.tonic_pc && @triad_type == other.triad_type
   end
 
   def clone
     Marshal.load(Marshal.dump(self))
   end
-  
-  def accidentals
-    unless @accidentals
-      @accidentals = []
-      unless accidental_free?
-        acc_type = accidental_type
-        idx = TONICS[@triad][acc_type].index(@tonic_pc)
-        @accidentals = ACCIDENTALS[acc_type].take(idx+1)
-      end
-    end
-    return @accidentals
-  end
-  
-  def accidental_type
-    if accidental_free? || TONICS[@triad][@accidental_pref].include?(@tonic_pc)
-      @accidental_pref
-    else
-      (@accidental_pref == FLAT) ? SHARP : FLAT
-    end
-  end
 
   def transpose interval
-    new_key = self.clone
-    new_key.tonic_pc += interval
-    return new_key
+    Key.new(PitchClass.from_i(@tonic_pc+interval), @triad_type)
   end
-
-  private
-
-  def reset_accidentals; @accidentals = nil; end
 end
 
 end

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

@@ -1,37 +1,38 @@
 module Musicality
 module Keys
-  C_MAJOR = Key.major_sharp(PitchClasses::C)
-  G_MAJOR = Key.major_sharp(PitchClasses::G)
-  D_MAJOR = Key.major_sharp(PitchClasses::D)
-  A_MAJOR = Key.major_sharp(PitchClasses::A)
-  E_MAJOR = Key.major_sharp(PitchClasses::E)
-  B_MAJOR = Key.major_sharp(PitchClasses::B)
-  F_SHARP_MAJOR = Key.major_sharp(PitchClasses::Fs)
-  C_SHARP_MAJOR = Key.major_sharp(PitchClasses::Cs)
-  
-  F_MAJOR = Key.major_flat(PitchClasses::F)
-  B_FLAT_MAJOR = Key.major_flat(PitchClasses::Bb)
-  E_FLAT_MAJOR = Key.major_flat(PitchClasses::Eb)
-  A_FLAT_MAJOR = Key.major_flat(PitchClasses::Ab)
-  D_FLAT_MAJOR = Key.major_flat(PitchClasses::Db)
-  G_FLAT_MAJOR = Key.major_flat(PitchClasses::Gb)
-  C_FLAT_MAJOR = Key.major_flat(PitchClasses::Cb)
-  
-  A_MINOR = Key.minor_sharp(PitchClasses::A)
-  E_MINOR = Key.minor_sharp(PitchClasses::E)
-  B_MINOR = Key.minor_sharp(PitchClasses::B)
-  F_SHARP_MINOR = Key.minor_sharp(PitchClasses::Fs)
-  C_SHARP_MINOR = Key.minor_sharp(PitchClasses::Cs)
-  G_SHARP_MINOR = Key.minor_sharp(PitchClasses::Gs)
-  D_SHARP_MINOR = Key.minor_sharp(PitchClasses::Ds)
-  A_SHARP_MINOR = Key.minor_sharp(PitchClasses::As)
-  
-  D_MINOR = Key.minor_flat(PitchClasses::D)
-  G_MINOR = Key.minor_flat(PitchClasses::G)
-  C_MINOR = Key.minor_flat(PitchClasses::C)
-  F_MINOR = Key.minor_flat(PitchClasses::F)
-  B_FLAT_MINOR = Key.minor_flat(PitchClasses::Bb)
-  E_FLAT_MINOR = Key.minor_flat(PitchClasses::Eb)
-  A_FLAT_MINOR = Key.minor_flat(PitchClasses::Ab)
+  C_MAJOR = Key.major(PitchClasses::C)
+
+  # Major keys with sharps
+  G_MAJOR = Key.major(PitchClasses::G)
+  D_MAJOR = Key.major(PitchClasses::D)
+  A_MAJOR = Key.major(PitchClasses::A)
+  E_MAJOR = Key.major(PitchClasses::E)
+  B_MAJOR = Key.major(PitchClasses::B)
+
+  # Major keys with flats
+  F_MAJOR = Key.major(PitchClasses::F)
+  Bb_MAJOR = Key.major(PitchClasses::Bb)
+  Eb_MAJOR = Key.major(PitchClasses::Eb)
+  Ab_MAJOR = Key.major(PitchClasses::Ab)
+  Db_MAJOR = Key.major(PitchClasses::Db)
+  Gb_MAJOR = Key.major(PitchClasses::Gb)
+
+  A_MINOR = Key.minor(PitchClasses::A)
+
+  # Minor keys with sharps
+  E_MINOR = Key.minor(PitchClasses::E)
+  B_MINOR = Key.minor(PitchClasses::B)
+  Fs_MINOR = Key.minor(PitchClasses::Fs)
+  Cs_MINOR = Key.minor(PitchClasses::Cs)
+  Gs_MINOR = Key.minor(PitchClasses::Gs)
+
+  # Minor keys with flats
+  D_MINOR = Key.minor(PitchClasses::D)
+  G_MINOR = Key.minor(PitchClasses::G)
+  C_MINOR = Key.minor(PitchClasses::C)
+  F_MINOR = Key.minor(PitchClasses::F)
+  Bb_MINOR = Key.minor(PitchClasses::Bb)
+  Eb_MINOR = Key.minor(PitchClasses::Eb)
+end
+
 end
-end

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

@@ -5,10 +5,10 @@ require 'set'
 class Note
   include Packable
   include Validatable
-  
+
   attr_reader :pitches, :links, :duration, :marks
   attr_accessor :articulation
-  
+
   def initialize duration, pitches = [], links: {}, articulation: Articulations::NORMAL, marks: []
     self.duration = duration
     if !pitches.is_a? Enumerable
@@ -19,18 +19,24 @@ class Note
     @articulation = articulation
     @marks = marks
   end
-  
+
   def check_methods
-    [ :check_pitches ]
+    [ :check_duration, :check_pitches ]
+  end
+
+  def check_duration
+    if duration <= 0
+      raise RangeError, "Duration is non-positive: #{duration}"
+    end
   end
-  
+
   def check_pitches
     non_pitches = @pitches.select {|p| !p.is_a?(Pitch) }
     if non_pitches.any?
       raise TypeError, "Found non-pitches: #{non_pitches}"
     end
   end
-  
+
   def == other
     return (@duration == other.duration) &&
     (self.pitches == other.pitches) &&
@@ -38,7 +44,7 @@ class Note
     (@articulation == other.articulation) &&
     (@marks == marks)
   end
-  
+
   def clone
     Marshal.load(Marshal.dump(self))
   end
@@ -55,10 +61,26 @@ class Note
     return new_note
   end
 
+  def tie_to pitches
+    new_note = self.clone
+    if pitches.is_a? Pitch
+      pitches = [pitches]
+    end
+
+    pitches.each do |pitch|
+      new_note.links[pitch] = Link::Tie.new
+    end
+    return new_note
+  end
+
+  def mark_accented!
+    @articulation = Articulations::ACCENT
+  end
+
   def transpose diff
     self.clone.transpose! diff
   end
-  
+
   def transpose! diff
     @pitches = @pitches.map {|pitch| pitch.transpose(diff) }
     @links = Hash[ @links.map do |k,v|
@@ -106,7 +128,7 @@ class Note
       Note.new(dur, pitches, articulation: articulation, links: links, marks: marks)
     end
   end
-  
+
   {
     :sixteenth => Rational(1,16),
     :dotted_sixteenth => Rational(3,32),

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

@@ -13,9 +13,9 @@ module Musicality
 # @author James Tunnell
 #
 # @!attribute [r] octave
-#   @return [Fixnum] The pitch octave.
+#   @return [Integer] The pitch octave.
 # @!attribute [r] semitone
-#   @return [Fixnum] The pitch semitone.
+#   @return [Integer] The pitch semitone.
 #
 class Pitch
   include Comparable

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

@@ -5,13 +5,19 @@ module Musicality
     CONVERSION_METHOD = :to_r
     include Parseable
   end
-  
+
   class Pitch
     PARSER = Parsing::PitchParser.new
     CONVERSION_METHOD = :to_pitch
     include Parseable
   end
-  
+
+  class Key
+    PARSER = Parsing::KeyParser.new
+    CONVERSION_METHOD = :to_key
+    include Parseable
+  end
+
   class Note
     PARSER = Parsing::NoteParser.new
     CONVERSION_METHOD = :to_note
@@ -23,7 +29,7 @@ module Musicality
     CONVERSION_METHOD = :to_meter
     include Parseable
   end
-  
+
   class Segment
     PARSER = Parsing::SegmentParser.new
     CONVERSION_METHOD = :to_range
@@ -37,38 +43,43 @@ class String
   end
   alias :to_dur :to_duration
   alias :to_d :to_duration
-  
+
   def to_durations pattern=" "
     Musicality::Duration.split_parse(self, pattern)
   end
   alias :to_durs :to_durations
   alias :to_ds :to_durations
-  
-  def to_pitch 
+
+  def to_pitch
     Musicality::Pitch.parse(self)
   end
   alias :to_p :to_pitch
-  
+
   def to_pitches pattern=" "
     Musicality::Pitch.split_parse(self, pattern)
   end
   alias :to_ps :to_pitches
-  
+
+  def to_key
+    Musicality::Key.parse(self)
+  end
+  alias :to_k :to_key
+
   def to_note
     Musicality::Note.parse(self)
   end
   alias :to_n :to_note
-  
+
   def to_notes pattern=" "
     Musicality::Note.split_parse(self, pattern)
   end
   alias :to_ns :to_notes
-  
+
   def to_meter
     Musicality::Meter.parse(self)
   end
-  
+
   def to_segment
     Musicality::Segment.parse(self)
   end
-end
+end

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

@@ -80,7 +80,7 @@ module Duration
         r2 = true
         @index += match_len
       else
-        terminal_parse_failure("/")
+        terminal_parse_failure('"/"')
         r2 = nil
       end
       s0 << r2
@@ -128,7 +128,7 @@ module Duration
         r3 = true
         @index += match_len
       else
-        terminal_parse_failure("/")
+        terminal_parse_failure('"/"')
         r3 = nil
       end
       if r3
@@ -173,7 +173,7 @@ module Duration
       r1 = true
       @index += match_len
     else
-      terminal_parse_failure("/")
+      terminal_parse_failure('"/"')
       r1 = nil
     end
     s0 << r1

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

@@ -0,0 +1,150 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module Musicality
+module Parsing
+
+module Key
+  include Treetop::Runtime
+
+  def root
+    @root ||= :key
+  end
+
+  include Pitch
+
+  module Key0
+    def pitch_letter
+      elements[0]
+    end
+
+    def mod
+      elements[1]
+    end
+
+    def major_minor
+      elements[2]
+    end
+  end
+
+  module Key1
+    def to_key
+      sem = pitch_letter.to_semitone
+      modval = 0
+      if !mod.empty?
+        modval = case mod.text_value
+        when "#" then 1
+        when "b" then -1
+        end
+      end
+
+      triad_type = if major_minor.text_value.include?("maj")
+        Musicality::Key::MAJOR
+      else
+        Musicality::Key::MINOR
+      end
+
+      return Musicality::Key.new(sem + modval, triad_type: triad_type)
+    end
+  end
+
+  def _nt_key
+    start_index = index
+    if node_cache[:key].has_key?(index)
+      cached = node_cache[:key][index]
+      if cached
+        node_cache[:key][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_pitch_letter
+    s0 << r1
+    if r1
+      if has_terminal?(@regexps[gr = '\A[#b]'] ||= Regexp.new(gr), :regexp, index)
+        r3 = true
+        @index += 1
+      else
+        terminal_parse_failure('[#b]')
+        r3 = nil
+      end
+      if r3
+        r2 = r3
+      else
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r2
+      if r2
+        r4 = _nt_major_minor
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Key0)
+      r0.extend(Key1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:key][start_index] = r0
+
+    r0
+  end
+
+  def _nt_major_minor
+    start_index = index
+    if node_cache[:major_minor].has_key?(index)
+      cached = node_cache[:major_minor][index]
+      if cached
+        node_cache[:major_minor][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    if (match_len = has_terminal?("maj", false, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"maj"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("min", false, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"min"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:major_minor][start_index] = r0
+
+    r0
+  end
+
+end
+
+class KeyParser < Treetop::Runtime::CompiledParser
+  include Key
+end
+
+
+end
+end

data/lib/musicality/notation/parsing/key_parsing.treetop

@@ -0,0 +1,37 @@
+module Musicality
+module Parsing
+
+grammar Key
+  include Pitch
+
+  rule key
+    pitch_letter mod:[#b]? major_minor {
+      def to_key
+        sem = pitch_letter.to_semitone
+        modval = 0
+        if !mod.empty?
+          modval = case mod.text_value
+          when "#" then 1
+          when "b" then -1
+          end
+        end
+
+        triad_type = if major_minor.text_value.include?("maj")
+          Musicality::Key::MAJOR
+        else
+          Musicality::Key::MINOR
+        end
+
+        return Musicality::Key.new(sem + modval, triad_type: triad_type)
+      end
+    }
+  end
+
+  rule major_minor
+    "maj" / "min"
+  end
+
+end
+
+end
+end

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

@@ -80,7 +80,7 @@ module Meter
         r2 = true
         @index += match_len
       else
-        terminal_parse_failure("/")
+        terminal_parse_failure('"/"')
         r2 = nil
       end
       s0 << r2
@@ -142,7 +142,7 @@ module Meter
         r2 = true
         @index += match_len
       else
-        terminal_parse_failure("*")
+        terminal_parse_failure('"*"')
         r2 = nil
       end
       s0 << r2
@@ -154,7 +154,7 @@ module Meter
             r4 = true
             @index += match_len
           else
-            terminal_parse_failure("/")
+            terminal_parse_failure('"/"')
             r4 = nil
           end
           s0 << r4

data/lib/musicality/notation/parsing/numbers/nonnegative_float_parsing.rb

@@ -36,12 +36,14 @@ module NonnegativeFloat
       r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
       r0 = r1
       r0.extend(NonnegativeFloat0)
+      r0.extend(NonnegativeFloat0)
     else
       r2 = _nt_float2
       if r2
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
         r0.extend(NonnegativeFloat0)
+        r0.extend(NonnegativeFloat0)
       else
         @index = i0
         r0 = nil
@@ -222,7 +224,7 @@ module NonnegativeFloat
       r1 = true
       @index += match_len
     else
-      terminal_parse_failure("e")
+      terminal_parse_failure('"e"')
       r1 = nil
     end
     s0 << r1