stretto 0.6.1

data/lib/stretto/music_elements/modifiers/attack_decay.rb

@@ -0,0 +1,55 @@
+module Stretto
+  module MusicElements
+
+    # This module encapsulates behavior for all elements that specify attack and decay values
+    #
+    # Attack represents the "warm up" of the note, and decay its "cool down", that is, the
+    # times it takes to the note to reach its main volume form 0 when building, and the
+    # inverse when going into silence. The default value for both is 0
+    module AttackDecay
+
+      DEFAULT_ATTACK = 64
+      DEFAULT_DECAY  = 64
+
+      attr_reader :original_attack, :original_decay
+
+      # Sets up the original attack and decay tokens
+      def build_attack_and_decay(original_attack, original_decay)
+        @original_attack = original_attack
+        @original_decay  = original_decay
+      end
+
+      # Sets the instance variable `@attack` and performs validation in range
+      #
+      # @raise [Exceptions::InvalidValueException] if the value is greater than 127
+      def attack=(attack)
+        @attack = attack || DEFAULT_ATTACK
+        if @attack < 0 or @attack > 127
+          raise Exceptions::InvalidValueException.new("Attack should be in the range 0..127")
+        end
+      end
+
+      # Sets the instance variable `@decay` and performs validation in range
+      #
+      # @raise [Exceptions::InvalidValueException] if the value is greater than 127
+      def decay=(decay)
+        @decay = decay || DEFAULT_DECAY
+        if @decay < 0 or @decay > 127
+          raise Exceptions::InvalidValueException.new("Decay should be in the range 0..127")
+        end
+      end
+
+      # @return [Number] Numeric value for attack, or the default one
+      def attack
+        @original_attack.to_i(@pattern) || DEFAULT_ATTACK
+      end
+
+      # @return [Number] Numeric value for delay, or the default one
+      def decay
+        @original_decay.to_i(@pattern) || DEFAULT_DECAY
+      end
+
+    end
+
+  end
+end

data/lib/stretto/music_elements/modifiers/chord_intervals.rb

@@ -0,0 +1,44 @@
+module Stretto
+  module MusicElements
+
+    class Chord < MusicElement
+
+      # The literal names of chord intervals.
+      # Values represent the semitones from the base note of the notes that form the chord.
+      CHORD_INTERVALS = {
+        'maj'       => [4, 7],
+        'min'       => [3, 7],
+        'aug'       => [4, 8],
+        'dim'       => [3, 6],
+        'dom7'      => [4, 7, 10],
+        'maj7'      => [4, 7, 11],
+        'min7'      => [3, 7, 10],
+        'sus4'      => [5, 7],
+        'sus2'      => [2, 7],
+        'maj6'      => [4, 7, 9],
+        'min6'      => [3, 7, 9],
+        'dom9'      => [4, 7, 10, 14],
+        'maj9'      => [4, 7, 11, 14],
+        'min9'      => [3, 7, 10, 14],
+        'dim7'      => [3, 6, 9],
+        'add9'      => [4, 7, 14],
+        'min11'     => [7, 10, 14, 15, 17],
+        'dom11'     => [7, 10, 14, 17],
+        'dom13'     => [7, 10, 14, 16, 21],
+        'min13'     => [7, 10, 14, 15, 21],
+        'maj13'     => [7, 11, 14, 16, 21],
+        'dom7<5'    => [4, 6, 10],
+        'dom7>5'    => [4, 8, 10],
+        'maj7<5'    => [4, 6, 11],
+        'maj7>5'    => [4, 8, 11],
+        'minmaj7'   => [3, 7, 11],
+        'dom7<5<9'  => [4, 6, 10, 13],
+        'dom7<5>9'  => [4, 6, 10, 15],
+        'dom7>5<9'  => [4, 8, 10, 13],
+        'dom7>5>9'  => [4, 8, 10, 15]
+      }
+      
+    end
+
+  end
+end

data/lib/stretto/music_elements/modifiers/duration.rb

@@ -0,0 +1,180 @@
+require 'rational'
+
+module Stretto
+  module MusicElements
+
+    # This module encapsulates behavior for elements that specify a duration.
+    #
+    # Duration can modify notes, chords and rests. It is specified after the note string,
+    # and its relative to the duration of the whole note (see {Tempo}). That means that a
+    # duration of 1.0 represents a whole note, 0.5 a half note, and 1.5 a whole and a half
+    # note, for instance.
+    #
+    # A duration may be indicated by the duration letters, or literally as a numeric
+    # value.
+    #
+    # In the first way, the letter for the duration is indicated, with the following values:
+    #
+    # +whole+:: w
+    # +half+:: h
+    # +quarter+:: q
+    # +eighth+:: i
+    # +sixteenth+:: s
+    # +thity-second+:: t
+    # +sixty-fourth+:: x
+    # +one-twenty-eighth+:: o
+    #
+    # The duration can be concatenated (so a duration of +hq+ qould be three quarters), and
+    # you may append one or more dot modifiers, that add half the value of the note succesively
+    # (see http://en.wikipedia.org/wiki/Dotted_note).
+    #
+    # Additionally, tuplets can be built by appending a tuplet notation, specified by the
+    # syntax +*+_numerator_+:+_denominator_ (see http://en.wikipedia.org/wiki/Tuplet for more
+    # information about tuplets). If omitter, the numerator and denominator will default to
+    # 3 and 2, respectively (most commonly called a triplet).
+    #
+    # The other way to specify a duration is to indicate its numeric value after a slash.
+    # For example, a C note with half duration can be expressed as +C/0.5+
+    # This notation does not accept dots or tuplets.
+    #
+    # The duration of a note can be tied, so its {#tied_duration tied duration} will be
+    # added to the next {#tied_elements tied elements}. To indicate the start or end of a tie,
+    # add a dash after or before the duration (For example, +Cw- C-w- C-h will tie two
+    # whole notes and a half note together). When added to a pattern, one can get the
+    # total duration of a note by calling {tied_duration}. All elements other than notes, chords
+    # or rests are ignored within tied notes (most notably {Measure measures})
+    module Duration
+
+      DURATIONS = { 'w' => Rational(1),
+                    'h' => Rational(1, 2),
+                    'q' => Rational(1, 4),
+                    'i' => Rational(1, 8),
+                    's' => Rational(1, 16),
+                    't' => Rational(1, 32),
+                    'x' => Rational(1, 64),
+                    'o' => Rational(1, 128) }
+
+      DEFAULT_DURATION = DURATIONS['q']
+      DEFAULT_TUPLET_NUMERATOR    = 3
+      DEFAULT_TUPLET_DENOMINATOR  = 2
+
+      attr_reader :original_duration
+      attr_reader :start_tie, :end_tie
+
+      # @param [Tokens::DurationToken, nil] duration_token
+      # @param [Rational, Number] default_duration The default duration if there's no token
+      def build_duration_from_token(duration_token, default_duration = DEFAULT_DURATION)
+        @original_duration_token = duration_token
+        @original_duration       = duration_token ? duration_token.text_value : ''
+        @processed_value         = Duration.parse_duration(@original_duration_token, default_duration)
+        if @original_duration_token
+          @start_of_tie          = @original_duration_token.start_of_tie?
+          @end_of_tie            = @original_duration_token.end_of_tie?
+        end
+      end
+
+      # Duration value is proportional to a whole note (one whole note = 1.0 duration).
+      #
+      # This method will coerce the duration to a float, but internally the elements can
+      # handle it as a rational number, to perform calculations more accurately.
+      #
+      # @return [Number] The value of the duration
+      def duration
+        case @processed_value
+          when Stretto::Value then @processed_value.to_f(@pattern)
+          else @processed_value
+        end
+      end
+
+      # @return [Boolean] If the note starts a tie, indicating the duration should continue
+      #   onto the next element
+      def start_of_tie?
+        @start_of_tie.present?
+      end
+
+      # @return [Boolean] If the note ends a tie, indicating the duration should extend
+      #   the duration of the previous element
+      def end_of_tie?
+        @end_of_tie.present?
+      end
+
+      # Returns an array containing all the elements that are tied to the right
+      #
+      # It can return an array consisiting on just the current element, if it is not tied
+      # or simply it doesn't belong to a pattern
+      #
+      # @return [Array(MusicElements::MusicElement)] Array of tied elements
+      def tied_elements
+        current = self
+        elements = [current]
+        while next_is_tied?(current)
+          current = current.next
+          elements << current unless current.kind_of?(Measure)
+        end
+        elements
+      end
+
+      # Returns the total duration of the tied elements
+      #
+      # @return [Number]
+      # @see #tied_elements
+      def tied_duration
+        tied_elements.inject(0){|sum, element| sum + element.duration}
+      end
+
+      # Parses duration from a token, or returning the default duration
+      #
+      # @return [Rational, Number]
+      def self.parse_duration(duration_token, default_duration = DEFAULT_DURATION)
+        if !duration_token
+          default_duration
+        elsif duration_token.value
+          duration_token.value
+        else
+          parse_duration_token(duration_token)
+        end
+      end
+
+      private
+
+        # Returns whether this note is start of tie, and the next one has end of tie.
+        # Ignores Measures, so it will return true even when there's one in between
+        #
+        # @return [Boolean]
+        def next_is_tied?(note)
+          note.start_of_tie?      &&
+            note.next             &&
+            note.next.end_of_tie? &&
+            (note.class == note.next.class || note.next.kind_of?(Measure) || note.kind_of?(Measure))
+        end
+
+        class << self
+
+          private
+
+            # Parses the duration when it comes as characters + modifiers
+            # (e.g. "wh.", "q*3:5")
+            #
+            # @return [Rational, Number]
+            def parse_duration_token(duration_token)
+              duration = duration_token.duration_character.split('').map do |char_duration| # TODO: deprecation. each_char is only 1.9+
+                DURATIONS[char_duration.downcase]
+              end.sum
+              original_duration = duration
+              duration_token.dots.times do |dot_duration|
+                duration += (original_duration * Rational(1,  2 ** (dot_duration + 1)))
+              end
+              if duration_token.tuplet
+                numerator = duration_token.tuplet[:numerator]     || DEFAULT_TUPLET_NUMERATOR
+                denominator = duration_token.tuplet[:denominator] || DEFAULT_TUPLET_DENOMINATOR
+                duration *= Rational(denominator.to_i, numerator.to_i)
+              end
+              duration
+            end
+
+        end
+
+    end
+
+  end
+end

data/lib/stretto/music_elements/modifiers/value.rb

@@ -0,0 +1,172 @@
+require File.dirname(__FILE__) + '/variables'
+
+module Stretto
+
+  # This class acts as a placeholder for values contained by musical elements.
+  #
+  # It is needed in order to retrieve values held by a variable until evaluation,
+  # looking for them in the pattern the element belongs, or one of the predefined
+  # variables.
+  class Value
+
+    # Wraps a numeric value
+    # @see Value
+    class NumericValue
+      
+      attr_reader :numeric
+
+      # @param [Number] The numeric value held
+      def initialize(numeric)
+        @numeric = numeric
+      end
+
+      # @return [Integer] The numeric value coerced to an integer
+      def to_i(pattern)
+        @numeric.to_i
+      end
+
+      # @return [Float] The numeric value coerced to a float
+      def to_f(pattern)
+        @numeric.to_f
+      end
+
+      # @return [Boolean] True if the value it is holding is equal to other's value
+      def ==(other)
+        other.kind_of?(NumericValue) && other.numeric == @numeric
+      end
+
+      # @return [String] The string representation of the numeric value
+      def to_s
+        @numeric.to_s
+      end
+    end
+
+    #--------------------------------------------------------------
+
+    # Wraps a variable value, that is, holds a reference to a value that is going
+    # to be evaluated until requested.
+    #
+    # @see Value
+    class VariableValue
+
+      include Variables
+
+      attr_reader :name
+
+      # @param [String] The name that references the variable
+      def initialize(name)
+        @name = name
+      end
+
+      # Returns the value of the variable as an integer
+      #
+      # @return [Integer]
+      # @raise (see #get_numeric_value)
+      def to_i(pattern)
+        get_numeric_value(pattern){ |value| value.to_i(pattern) }
+      end
+
+      # Returns the value of the variable as a float
+      #
+      # @return [Float]
+      # @raise (see #get_numeric_value)
+      def to_f(pattern)
+        get_numeric_value(pattern){ |value| value.to_f(pattern) }
+      end
+
+      # Returns either the variable value if attached to a pattern, or raises an exception
+      # if there is no pattern attached and the variable is not one of the predefined ones.
+      def value(pattern)
+        if pattern
+          pattern.variable(@name)
+        else
+          predefined = PREDEFINED_VARIABLES[name.upcase]
+          unless predefined
+            raise Stretto::Exceptions::VariableContextException.new(
+                "A pattern is needed to access variable #{@name}")
+          end
+          Value.new(Value::NumericValue.new(predefined))
+        end
+      end
+
+      # Returns whether the other object is the same class and holds the same variable name
+      def ==(other)
+        other.kind_of?(VariableValue) && other.name == @name
+      end
+
+      # Name of the variable, enclosed in brackets
+      #
+      # @return [String]
+      def to_s
+        "[#{@name}]"
+      end
+
+      private
+
+        # Gets the numeric value of the variable.
+        #
+        # It does indirection, that is, if the value holding is a variable itself,
+        # looks up recursively.
+        #
+        # @raise [VariableContextException] if the variable is not one of the predefined values
+        #   and there is no pattern attached
+        # @raise [VariableNotDefinedException] if the variable is not defined in the pattern
+        def get_numeric_value(pattern)
+          variable = self
+          variable = yield variable.value(pattern) until variable.kind_of?(Numeric)
+          variable
+        end
+    end
+
+    #--------------------------------------------------------------
+
+    # Initializes with the value passed in, and an optional variation.
+    #
+    # @param value [NumericValue, VariableValue]
+    # @param variation [Number] Works as a delayed addition, so you can do things like
+    #      `Value.new(VariableValue.new("SOME_VAR")) + 1`
+    #   and have it evaluated until requested 
+    def initialize(value, variation = nil)
+      @value = value
+      @variation = variation
+    end
+
+    # Converts the value to integer
+    #
+    # @return [Integer, nil]
+    def to_i(pattern)
+      if @value
+        result = @value.to_i(pattern)
+        result += @variation if @variation
+        result
+      end
+    end
+
+    # Converts the value to float
+    #
+    # @return [Float, nil]
+    def to_f(pattern)
+      if @value
+        result = @value.to_f(pattern)
+        result += @variation if @variation
+        result
+      end
+    end
+
+    # Adds a variation to the Value, returning a new one with the sum of variations
+    #
+    # @return [Value]
+    def +(variation)
+      new_variation = [@variation, variation].compact.sum
+      self.class.new(@value, new_variation)
+    end
+
+    # String representation for this value, either a number or the name of the variable.
+    def to_s
+      output = @value.to_s
+      output += "+#{@variation}" if @variation
+      output
+    end
+
+  end
+end