stretto 0.6.1

data/lib/stretto/grammar/tempo_grammar.treetop

@@ -0,0 +1,9 @@
+grammar TempoGrammar
+
+  include ValueGrammar
+
+  rule tempo
+    kind:'T' __value:variable_or_integer <Stretto::Tokens::TempoToken>
+  end
+
+end

data/lib/stretto/grammar/timing_grammar.treetop

@@ -0,0 +1,9 @@
+grammar TimingGrammar
+
+  include ValueGrammar
+
+  rule timing
+    kind:'@' __value:variable_or_integer <Stretto::Tokens::TimingToken>
+  end
+
+end

data/lib/stretto/grammar/tokens/attack_decay_token.rb

@@ -0,0 +1,42 @@
+module Stretto
+  module Tokens
+
+    # Token result from parsing attack and decay syntax
+    #
+    # @example "a100d[VAR]"
+    class AttackDecayToken < Treetop::Runtime::SyntaxNode
+
+      # @return [NumericToken, VariableToken, nil]
+      def attack
+        _attack.value.wrap if _attack and _attack.text_value.present?
+      end
+
+      # @return [NumericToken, VariableToken, nil]
+      def decay
+        _decay.value.wrap if _decay and _decay.text_value.present?
+      end
+
+    end
+
+
+    # Include this module to access functionality of attack and decay tokens
+    #
+    # @see #attack
+    # @see #decay
+    module WithAttackDecayToken
+
+      # @return [Value, nil] The attack value wrapped by a Value object, or nil
+      def attack
+        attack = attack_and_decay.attack
+        Stretto::Value.new(attack)
+      end
+
+      # @return [Value, nil] The decay value wrapped by a Value object, or nil
+      def decay
+        decay = attack_and_decay.decay
+        Stretto::Value.new(decay)
+      end
+    end
+  end
+
+end

data/lib/stretto/grammar/tokens/chord_token.rb

@@ -0,0 +1,67 @@
+require File.join(File.dirname(__FILE__), 'duration_token')
+require File.join(File.dirname(__FILE__), 'note_string_token')
+require File.join(File.dirname(__FILE__), 'attack_decay_token')
+require File.join(File.dirname(__FILE__), '../../music_elements/chord')
+
+module Stretto
+  module Tokens
+
+    # Parses a named chord
+    #
+    # @example: "C5#maj"
+    class ChordToken < HashToken
+
+      include WithDurationToken
+      include WithNoteStringToken
+      include WithAttackDecayToken
+
+      # @return [MusicElements::Chord] The constructed Chord element
+      def to_stretto(pattern = nil)
+        Stretto::MusicElements::Chord.new(self, pattern)
+      end
+
+      # Returns a base note hash, which can be seen as a token returned by the
+      # parsed note
+      def base_note
+        {
+            :text_value => note_string.text_value,
+            :key        => key,
+            :pitch      => pitch,
+            :accidental => accidental,
+            :octave     => octave,
+            :attack     => attack,
+            :decay      => decay,
+            :duration   => duration
+        }
+      end
+
+      # @return [NoteStringToken]
+      def note_string
+        __note_string
+      end
+
+      # @return A string containing the named chord
+      # @example "sus4"
+      def named_chord
+        __named_chord.text_value
+      end
+
+      # If inversions are present, return a hash containing the pivot note
+      #   (e.g. "^C") or the number of inversions (e.g. 5)
+      def inversions
+        if __chord_inversions and __chord_inversions.text_value.present?
+          { :inversions => __chord_inversions.inversions,
+            :pivot_note => __chord_inversions.pivot_note }
+        end
+      end
+
+      # Don't precalculate values. Added for harmonic chords to be able to be
+      # constructed from a chord token.
+      # @private
+      def notes
+        nil
+      end
+
+    end
+  end
+end

data/lib/stretto/grammar/tokens/controller_change_token.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), '../../music_elements/controller_change')
+
+module Stretto
+  module Tokens
+    
+    # Token result from parsing a controller change
+    class ControllerChangeToken < HashToken
+
+      # @return [MusicElements::ControllerChange]
+      def to_stretto(pattern)
+        Stretto::MusicElements::ControllerChange.new(self, pattern)
+      end
+
+      # @return [Value]
+      def controller
+        Value.new(__controller.wrap)
+      end
+
+      # @return [Value]
+      def value
+        Value.new(__value.wrap)
+      end
+
+    end
+  end
+end

data/lib/stretto/grammar/tokens/duration_token.rb

@@ -0,0 +1,55 @@
+module Stretto
+  module Tokens
+
+    # Token result from parsing a duration
+    #
+    # @example "wh", "q*3:4", "/2.5"
+    class DurationToken < Treetop::Runtime::SyntaxNode
+
+      # @return [true, false] if the duration starts a tie (e.g., "w-")
+      def start_of_tie?
+        _start_of_tie.text_value.present? if _start_of_tie
+      end
+
+      # @return [true, false] if the duration ends a tie (e.g., "-w")
+      def end_of_tie?
+        _end_of_tie.text_value.present? if _end_of_tie
+      end
+
+      # @return [Hash, nil] A hash containing both the numerator and denominator, if present
+      # @example { :numerator => 2, :denominator => 3 }
+      def tuplet
+        if duration_string.tuplet
+          {:numerator   => duration_string.tuplet.numerator,
+           :denominator => duration_string.tuplet.denominator}
+        end
+      end
+
+      # @return [String] The duration expressed as characters
+      # @example "h", "wq"
+      def duration_character
+        duration_string.duration_character
+      end
+
+      # @return [Value, nil] A value wrapping the value of the duration, if present
+      def value
+        Stretto::Value.new(duration_string.value.wrap) if duration_string.value
+      end
+
+      # @return [String] Returns a string with the number of dots in the duration
+      # @example 2 (for string Cmajh..
+      def dots
+        duration_string.dots
+      end
+
+    end
+
+    # Include this module to obtain functionality for duration token
+    module WithDurationToken
+      def duration
+        __duration if __duration and __duration.text_value.present?
+      end
+    end
+
+  end
+end

data/lib/stretto/grammar/tokens/harmonic_chord_token.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), '/../../music_elements/harmonic_chord')
+
+module Stretto
+  module Tokens
+
+    # Token result from parsing a duration
+    #
+    # @example "C+D+E"
+    class HarmonicChordToken < HashToken
+
+      # @return [MusicElements::HarmonicChord] The constructed HarmonicChord element
+      def to_stretto(pattern = nil)
+        @pattern = pattern
+        Stretto::MusicElements::HarmonicChord.new(self, pattern)
+      end
+
+      # @return [Array<MusicElement>] The notes that form this chord
+      def notes
+        [_first_element.to_stretto(@pattern)] +
+            _other_elements.elements.map{|element| element._element.to_stretto(@pattern)}
+      end
+
+    end
+  end
+end

data/lib/stretto/grammar/tokens/harmony_with_melody_token.rb

@@ -0,0 +1,66 @@
+require File.join(File.dirname(__FILE__), '../../music_elements/harmony')
+require File.join(File.dirname(__FILE__), '../../music_elements/melody')
+
+module Stretto
+  module Tokens
+
+    # Token result from parsing a harmony
+    #
+    # @example "Cmajh+Dh_+Ew"
+    class HarmonyWithMelodyToken < HashToken
+
+
+      # @return [MusicElements::Harmony, MusicElements::Melody] Returns the constructed
+      #   Harmony or Melody object. It is a Harmony when there is more than one element
+      #   (e.g. "A+B_C")
+      def to_stretto(pattern = nil)
+        @pattern = pattern
+        music_elements = harmony_elements(pattern)
+        if music_elements.size == 1 and music_elements.first.kind_of?(Stretto::MusicElements::Melody)
+          music_elements.first
+        else
+          Stretto::MusicElements::Harmony.new(self, pattern)
+        end
+      end
+
+      # @return [Array(MusicElements::MusicElement)] AN array of the music elements that form the harmony
+      def music_elements
+        @music_elements ||= harmony_elements(@pattern)
+      end
+
+      private
+
+        # Builds the Melody objects or the single elements that form a harmony 
+        #-
+        # TODO: This can be refactored, even return the melodies directly from the token
+        def harmony_elements(pattern)
+          elements = [_first_element.to_stretto]
+          original_strings = [_first_element.text_value]
+          _other_elements.elements.each do |e|
+            element = e._element.to_stretto
+            case e._sep.text_value
+              when '_'
+                elements << [elements.pop] unless elements.last.kind_of?(Array)
+                elements.last << element
+                original_strings[-1] += element.original_string
+              when '+'
+                elements << element
+                original_strings << element.original_string
+            end
+          end
+          elements.zip(original_strings).map do |element, string|
+            if element.kind_of?(Array)
+              Stretto::MusicElements::Melody.new(
+                  { :original_string => string,
+                    :elements        => element },
+                    pattern
+              )
+            else
+              element
+            end
+          end
+        end
+
+    end
+  end
+end

data/lib/stretto/grammar/tokens/hash_token.rb

@@ -0,0 +1,15 @@
+module Stretto
+  module Tokens
+
+    # Subclass of a parser token that overrides the #[] method to act like a Hash
+    class HashToken < Treetop::Runtime::SyntaxNode
+
+      # Quack like a hash. This is to make the individual element constructor accept either a hash
+      # or a token
+      def [](key)
+        send(key)
+      end
+
+    end
+  end
+end

data/lib/stretto/grammar/tokens/key_signature_token.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), '../../music_elements/key_signature')
+
+module Stretto
+  module Tokens
+
+    # Token result from parsing a key signature
+    #
+    # @example "KGmaj"
+    class KeySignatureToken < HashToken
+
+      # @return [MusicElements::KeySignature] The constructed token
+      def to_stretto(pattern = nil)
+        Stretto::MusicElements::KeySignature.new(self, pattern)
+      end
+
+      # @return A string with the key
+      # @example "C#"
+      def key
+        __note_key.text_value
+      end
+
+      # @return ['maj', 'min'] The scale of the key signature
+      def scale
+        __scale.text_value
+      end
+
+    end
+
+  end
+end

data/lib/stretto/grammar/tokens/measure_token.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), '../../music_elements/measure')
+
+module Stretto
+  module Tokens
+
+    # Token result from parsing a measure
+    #
+    #-
+    # Right now, the only supported measure is "|"
+    # TODO: Add support for other measures? (Repeat signs, codas, etc.)
+   class MeasureToken < HashToken
+
+     # @return [MusicElements::Measure] The constructed Measure element
+     def to_stretto(pattern = nil)
+       Stretto::MusicElements::Measure.new(self, pattern)
+     end
+
+   end
+
+  end
+end

data/lib/stretto/grammar/tokens/modifier_token.rb

@@ -0,0 +1,99 @@
+require File.join(File.dirname(__FILE__), '../../music_elements/modifiers/value')
+require File.join(File.dirname(__FILE__), '../../music_elements/instrument')
+require File.join(File.dirname(__FILE__), '../../music_elements/voice_change')
+require File.join(File.dirname(__FILE__), '../../music_elements/layer_change')
+require File.join(File.dirname(__FILE__), '../../music_elements/tempo')
+require File.join(File.dirname(__FILE__), '../../music_elements/pitch_bend')
+require File.join(File.dirname(__FILE__), '../../music_elements/channel_pressure')
+require File.join(File.dirname(__FILE__), '../../music_elements/timing')
+
+module Stretto
+  module Tokens
+
+    # Token result from parsing a modifier token.
+    # This encloses all elements that are constructed by a single character and a value.
+    # Refer to individual class to see the MusicElement generated from this token
+    #
+    # @example "I40". "T[ALLEGRO]", "@2000"
+    class ModifierToken < HashToken
+
+      # Returns an element of class KLASS
+      # @abstract
+      # @return [MusicElements::MusicElement]
+      # @see ModifierToken::KLASS
+      def to_stretto(pattern = nil)
+        self.class::KLASS.new(self, pattern)
+      end
+
+      # @return [Value] A Value object wrapping the value of the modifier
+      def value
+        Value.new(__value.wrap)
+      end
+      
+    end
+
+    # Token result from parsing an instrument
+    #
+    # @example "I[FLUTE]"
+    class InstrumentToken < ModifierToken
+
+      # @private
+      KLASS = Stretto::MusicElements::Instrument
+    end
+
+    # Token result from parsing a voice
+    #
+    # @example "V10"
+    class VoiceChangeToken < ModifierToken
+
+      # @private
+      KLASS = Stretto::MusicElements::VoiceChange
+    end
+
+    # Token result from parsing a layer
+    #
+    # @example "L5"
+    class LayerChangeToken < ModifierToken
+
+      # @private
+      KLASS = Stretto::MusicElements::LayerChange
+    end
+
+    # Token result from parsing a tempo
+    #
+    # @example "T200", "T[ALLEGRO]"
+    class TempoToken < ModifierToken
+
+      # @private
+      KLASS = Stretto::MusicElements::Tempo
+    end
+
+    # Token result from parsing a pitch bend
+    #
+    # @example "&9001"
+    class PitchBendToken < ModifierToken
+
+      # @private
+      KLASS = Stretto::MusicElements::PitchBend
+    end
+
+    # Token result from parsing a channel pressure
+    #
+    # @example "+80"
+    class ChannelPressureToken < ModifierToken
+
+      # @private
+      KLASS = Stretto::MusicElements::ChannelPressure
+    end
+
+    # Token result from parsing a timing indication
+    #
+    # @example "@2000"
+    class TimingToken < ModifierToken
+
+      # @private
+      KLASS = Stretto::MusicElements::Timing
+    end
+
+  end
+end