stretto 0.6.1

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

@@ -0,0 +1,106 @@
+module Stretto
+  module Tokens
+
+
+    # Token from parsing a note pitch, when an explicit pitch is given.
+    #
+    # @example "[60]". "[SOME_NOTE]"
+    module NotePitchToken
+
+      # Always return nil
+      # @return nil
+      def accidental
+        nil
+      end
+
+      # Always return nil
+      # @return nil
+      def octave
+        nil
+      end
+
+      # Always return nil
+      # @return nil
+      def key
+        nil
+      end
+
+      # Wraps the value into a Value object, either a numeric or a variable value
+      # @return [Value] The wrapped value for the pitch
+      def pitch
+        klass = if _pitch.is_numeric?
+          Value::NumericValue
+        else
+          Value::VariableValue
+        end
+        Value.new(klass.new(_pitch.text_value))
+      end
+    end
+
+    #------------------------------------------------------------------
+
+    # Token result from parsing the part of a note that contains key, and optional
+    # accidental and octave values
+    #
+    # @example "C#7"
+    module NoteKeyAccidentalOctaveToken
+
+      # @return [String] The key of the note ('A' through 'G')
+      # @example "C"
+      def key
+        note_key.key.text_value
+      end
+
+      # @return [String, nil] The accidental of the note, if present (one of 'bb', 'b', 'n', '#', '##')
+      # @example "#"
+      def accidental
+        note_key.accidental.text_value if note_key.accidental and note_key.accidental.text_value.present?
+      end
+
+      # Always return nil, as this is used to differentiate a note with a given pitch from one with key,
+      # octave and accidental whose pitch has to be calculated
+      # @return [nil]
+      def pitch
+        nil
+      end
+
+      # @return [String, nil] The octave of the note, if present
+      # @example "5"
+      def octave
+        _octave.text_value if _octave and _octave.text_value.present?
+      end
+    end
+
+    #------------------------------------------------------------------
+
+    # Include this module to include note string functionality, that is, to provide
+    # key, accidental, octave and/or pitch
+    module WithNoteStringToken
+
+      # @return (see NoteKeyAccidentalOctaveToken#octave)
+      # @return (see NotePitchToken#octave)
+      def octave
+        note_string.octave
+      end
+
+      # @return (see NoteKeyAccidentalOctaveToken#accidental)
+      # @return (see NotePitchToken#accidental)
+      def accidental
+        note_string.accidental
+      end
+
+      # @return (see NoteKeyAccidentalOctaveToken#key)
+      # @return (see NotePitchToken#key)
+      def key
+        note_string.key
+      end
+
+      # @return (see NoteKeyAccidentalOctaveToken#pitch)
+      # @return (see NotePitchToken#pitch)
+      def pitch
+        note_string.pitch
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,25 @@
+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/note')
+
+module Stretto
+  module Tokens
+
+    # Token result from parsing a note element. It includes the note string, attack, decay and duration
+    #
+    # @example "C", "F#6", "[60]w.", "Gb/3.0a100d100"
+    class NoteToken < HashToken
+
+      include WithDurationToken
+      include WithNoteStringToken
+      include WithAttackDecayToken
+
+      # @return [MusicElements::Note] The constructed Note element
+      def to_stretto(pattern = nil)
+        Stretto::MusicElements::Note.new(self, pattern)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Stretto
+  module Tokens
+
+    # This is the token that parses a pattern, that is, a collection of music elements
+    #
+    # @example "T[ALLEGRO] I[PIANO] | C C D E | Rw. | Dmin"
+    module PatternToken
+
+      # @return [Array(MusicElements::MusicElement)] An array containing all the elements of
+      #   the pattern
+      #-
+      # TODO: This should return a Pattern object directly
+      def to_stretto(pattern = nil)
+        unless head.text_value.empty?
+          [head.to_stretto(pattern)] + more_elements.elements.map do |element|
+            element.music_element.to_stretto(pattern)
+          end
+        else
+          []
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), '../../music_elements/polyphonic_pressure')
+
+module Stretto
+  module Tokens
+
+    # Token from parsing a polyphonic pressure element
+    #
+    # @example "*80,100"
+    class PolyphonicPressureToken < HashToken
+
+      # @return [MusicElements::PolyphonicPressure] The PolyphonicPressure element constructed
+      def to_stretto(pattern = nil)
+        Stretto::MusicElements::PolyphonicPressure.new(self, pattern)
+      end
+
+      # @return [Value] Value of the pitch to apply pressure
+      def pitch
+        Stretto::Value.new(__pitch.wrap)
+      end
+
+      # @return [Value] Value of the pressure applied
+      def value
+        Stretto::Value.new(__value.wrap)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), 'duration_token')
+require File.join(File.dirname(__FILE__), '../../music_elements/rest')
+
+module Stretto
+  module Tokens
+
+    # Token from parsing a rest element
+    #
+    # @example "R", "Rq"
+    class RestToken < HashToken
+
+      include WithDurationToken
+
+      # @return [MusicElement::Rest] The Rest element constructed
+      def to_stretto(pattern = nil)
+        Stretto::MusicElements::Rest.new(self, pattern)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Stretto
+  module Tokens
+
+    # Represents a numeric value (either decimal or integer) parsed from a music string
+    # @example "10.5"
+    # @see VariableToken
+    module NumericToken
+
+      # @return [Value::NumericValue] A NumericValue with the parsed text as a float number
+      def wrap
+        Stretto::Value::NumericValue.new(text_value.to_f)
+      end
+    end
+
+    # Represents a variable value parsed from a music string
+    # @example "[SOME_VARIABLE]"
+    # @see NumericToken
+    module VariableToken
+
+      # @return [Value::VariableValue] A VariableValue with the parsed text as the name of
+      #   the variable it references
+      def wrap
+        Stretto::Value::VariableValue.new(name.text_value)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), '../../music_elements/variable')
+
+module Stretto
+  module Tokens
+
+    # Token from parsing a variable definition
+    #
+    # @example "$MY_VAR=80", "$OTHER_VAR=[SOME_NOTE_VAR]"
+    class VariableDefinitionToken < HashToken
+
+      # @return [MusicElements::Variable] The constructed Variable element
+      def to_stretto(pattern = nil)
+        Stretto::MusicElements::Variable.new(self, pattern)
+      end
+
+      # @return [String] The name of the variable
+      def name
+        __name.text_value
+      end
+
+      # @return [Value] The value of the variable, a Value object
+      #   wrapping either a numeric or another variable value
+      def value
+        Stretto::Value.new(__value.wrap)
+      end
+
+    end
+
+  end
+end

data/lib/stretto/grammar/value_grammar.treetop

@@ -0,0 +1,45 @@
+grammar ValueGrammar
+
+  rule variable_or_integer
+    variable <Stretto::Tokens::VariableToken>
+    /
+    integer <Stretto::Tokens::NumericToken>
+  end
+
+  rule variable_or_decimal
+    variable <Stretto::Tokens::VariableToken>
+    /
+    decimal <Stretto::Tokens::NumericToken>
+  end
+
+  rule integer
+    "0" / [1-9] [0-9]*
+  end
+
+  rule decimal
+    integer ('.' [0-9]+)?
+  end
+
+  rule variable
+    '[' name:variable_name ']'
+  end
+
+  rule variable_name
+    [A-Za-z_] [A-Za-z0-9_]+
+  end
+
+  rule integer_or_variable_name
+    integer {
+      def is_numeric?
+        true
+      end
+    }
+    /
+    variable_name {
+      def is_numeric?
+        false
+      end
+    }
+  end
+
+end

data/lib/stretto/grammar/variable_grammar.treetop

@@ -0,0 +1,10 @@
+grammar VariableGrammar
+
+  include ValueGrammar
+
+  rule variable_definition
+    # It can be set to a integer also, but decimal handles that case
+    '$' __name:variable_name '=' __value:variable_or_decimal <Stretto::Tokens::VariableDefinitionToken>
+  end
+
+end

data/lib/stretto/grammar/voice_change_grammar.treetop

@@ -0,0 +1,9 @@
+grammar VoiceChangeGrammar
+
+  include ValueGrammar
+
+  rule voice
+    kind:'V' __value:variable_or_integer <Stretto::Tokens::VoiceChangeToken>
+  end
+
+end

data/lib/stretto/music_elements/channel_pressure.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), 'music_element')
+
+module Stretto
+  module MusicElements
+
+    # ChannelPressure sends a MIDI message similar to applying pressure to an
+    # electronic keyboard. This event applies pressure to the whole channel, and its
+    # value can rango from 0 to 127
+    class ChannelPressure < MusicElement
+
+      MAX_CHANNEL_PRESSURE_VALUE = 127
+
+      def initialize(string_or_options, pattern = nil)
+        token = case string_or_options
+          when String then Stretto::Parser.parse_channel_pressure!(string_or_options)
+          else string_or_options
+        end
+        super(token[:text_value], pattern)
+        @original_value = token[:value]
+      end
+
+      # Sets value and validates in range
+      def value=(value)
+        if value < 0 or value > MAX_CHANNEL_PRESSURE_VALUE
+          raise Exceptions::ValueOutOfBoundsException.new("Channel pressure should be in range 0..#{MAX_CHANNEL_PRESSURE_VALUE}")
+        end
+        @value = value
+      end
+
+      def value
+        @value || @original_value.to_i(@pattern)
+      end
+
+      private
+
+        # @private
+        def substitute_variables!
+          self.value = value
+        end
+
+    end
+
+  end
+end

data/lib/stretto/music_elements/chord.rb

@@ -0,0 +1,194 @@
+require File.join(File.dirname(__FILE__), 'music_element')
+require File.join(File.dirname(__FILE__), 'modifiers/attack_decay')
+require File.join(File.dirname(__FILE__), 'modifiers/chord_intervals')
+require 'forwardable'
+
+module Stretto
+  module MusicElements
+
+    # A chord indicates a group of notes that can be played together.
+    #
+    # The most common chord is a named chord. This is indicated by a note string
+    # (see {Note}) and the name of the chord. For example, chord C major is
+    # represented by +Cmaj+, and it will consist on the notes C, E and G (for definition,
+    # according to the musical theory).
+    #
+    # The chord can also indicate a duration (see {Duration}) and attack and decay (see
+    # {AttackDecay}), which have to be inserted after the named chord. For example, the chord
+    # +C#5maj7wa80d100+ has a base note of +C#5+, is the major 7th chord (+maj7+) with a
+    # whole duration (+w+), and has attack 80 and decay 100 (+a80d100+). The default octave
+    # for chords is 3
+    #
+    # For a list of supported chords see the JFugue reference guide, or the source code
+    # for {CHORD_INTERVALS}
+    #
+    # A chord can be inverted; that is, some of its notes is raised or lowered an octave, also
+    # called as the voicing of a chord. Chord inversions can be specified by two ways.
+    # The first one is to indicate with the symbol +^+ the number of notes that will be raised
+    # a whole octave (for example, the chord +C5maj+ will have notes C5, E5 and G5, its
+    # inversion +C5maj^+ will have E5, G5 and E6, and +C5maj^^+ notes G5, C6 and E6). The other
+    # way is to indicate explicitely the pivot note to invert from (the note +C5maj^E5+ is
+    # equivalent to the first inversion). It will raise an error if a chord is tried to
+    # be inverted by a note that is not part of the chord.
+    #
+    # This class can also hold non-regular chords, called harmonic chords. See {HarmonicChord}
+    class Chord < MusicElement
+
+      include Duration
+      include AttackDecay
+
+      DEFAULT_OCTAVE = 3
+
+      attr_reader :original_named_chord, :named_chord
+      attr_reader :key_signature
+      attr_accessor :instrument
+
+      extend Forwardable
+      def_delegators :@base_note, :original_accidental, :accidental,
+                                  :original_pitch,      :pitch,
+                                  :original_key,        :key,
+                                  :original_octave,     :octave,
+                                  :original_attack,     :attack,
+                                  :original_decay,      :decay
+
+      def initialize(string_or_options, pattern = nil)
+        token = case string_or_options
+          when String then Stretto::Parser.parse_chord!(string_or_options)
+          else string_or_options
+        end
+        super(token[:text_value], pattern)
+        unless @notes = token[:notes]
+          build_duration_from_token(token[:duration])
+          @original_base_note   = token[:base_note]
+          @original_named_chord = token[:named_chord]
+          @named_chord          = @original_named_chord.downcase
+          @original_inversions  = token[:inversions]
+          @base_note            = base_note
+          build_attack_and_decay(token[:attack], token[:decay])
+        end
+      end
+
+      # @return [Array(MusicElements::Note)] The array of notes generated by this chord
+      def notes
+        unless @notes
+          build_chord_notes(@named_chord)
+          build_inversions
+        end
+        @notes
+      end
+
+      # Returns the base note of the chord, that is, the note the chord was specified with.
+      #
+      # Note that this is not necessarily equal to the first note in the chord. If it has
+      # inversions, the base note will be kept as the original note, but the
+      # +notes+ construct will be effectively transposed.
+      def base_note
+        @base_note || build_base_note(@original_base_note)
+      end
+
+      # @return [Boolean] True if all the notes of the chord are equal
+      # @see MusicElements::Note#==
+      def ==(other)
+        notes && notes == other.notes
+      end
+
+      # @return [Number] The number of inversions of the chord
+      # @example
+      #    Chord.new("Cmaj^^").inversions # => 2
+      def inversions
+        build_inversions unless @inversions
+        @inversions
+      end
+
+      # @return [MusicElements::Note] The pivot note in which do the inversion, if specified
+      # @example
+      #   Chord.new("Cmaj^E").pivot_note # => Note<@key="E">
+      def pivot_note
+        build_inversions unless @pivot_note
+        @pivot_note
+      end
+
+      # Assigns the key signature for the chord, and for all of its notes.
+      #
+      # @see MusicElements::Note#key_signature=
+      def key_signature=(key_signature)
+        @key_signature = key_signature
+        if @base_note
+          @base_note.key_signature = key_signature
+          build_chord_notes(@named_chord)
+          build_inversions
+        end
+        @notes.each{ |note| note.pattern = @pattern }
+      end
+
+      private
+
+        # Builds the base_note according to the parsed token
+        def build_base_note(base_note_options)
+          Note.new({
+              :text_value => base_note_options[:text_value],
+              :octave     => base_note_options[:octave] || DEFAULT_OCTAVE,
+              :accidental => base_note_options[:accidental],
+              :key        => base_note_options[:key],
+              :pitch      => base_note_options[:pitch],
+              :attack     => base_note_options[:attack],
+              :decay      => base_note_options[:decay],
+              :duration   => base_note_options[:duration] },
+            @pattern
+          )
+        end
+
+        # When a named chord is specified, returns an array of the notes consisting
+        # on the base note plus the note with the intervals applied
+        def build_chord_notes(named_chord)
+          @named_chord = named_chord
+          intervals   = CHORD_INTERVALS[@named_chord]
+          @notes = [@base_note] + intervals.map{|interval| @base_note + interval}
+        end
+
+        # Builds either implicit (+^+) or explicit (+^+_note_) inversions
+        def build_inversions
+          if @original_inversions
+            @inversions = @original_inversions[:inversions]
+            pivot_note  = @original_inversions[:pivot_note]
+            if pivot_note
+              @pivot_note = Note.new({
+                  :text_value => pivot_note.text_value,
+                  :key        => pivot_note.key,
+                  :pitch      => pivot_note.pitch,
+                  :accidental => pivot_note.accidental,
+                  :octave     => pivot_note.octave || DEFAULT_OCTAVE,
+                  :duration   => @original_duration_token,
+                  :attack     => @original_attack,
+                  :decay      => @original_decay
+              }, @pattern)
+              @pivot_note.pattern = @pattern
+            end
+          else
+            @inversions = 0
+          end
+          raise Exceptions::ChordInversionsException.new("Number of inversions (#{@inversions}) is greater than chord size (#{notes.size})") if @inversions >= notes.size
+
+          notes.each{ |note| note.pattern = @pattern }
+          if @pivot_note
+            actual_pivot = notes.index(notes.find { |note| @pivot_note.pitch == note.pitch }) # TODO: Dropped notes.index(&block) for compatibility with <1.8.7
+            raise Exceptions::ChordInversionsException.new("Note #{@pivot_note.original_string}(#{@pivot_note.pitch}) does not belong to chord #{@original_string}") unless actual_pivot
+            actual_pivot.times { notes << notes.shift + 12 }
+          else
+            @inversions.times  { notes << notes.shift + 12 }
+          end
+        end
+
+
+        # @private
+        # @see MusicElements::MusicElement#substitute_variables!
+        def substitute_variables!
+          @base_note.pattern = @pattern
+          build_chord_notes(@named_chord)
+          build_inversions
+        end
+
+    end
+
+  end
+end