mtk 0.0.2 → 0.0.3

data/lib/mtk/helpers/pseudo_constants.rb

@@ -0,0 +1,26 @@
+module MTK
+  module Helpers
+
+    # Extension for modules that want to define pseudo-constants (constant-like values with lower-case names)
+    module PseudoConstants
+
+      # Define a module method and module function (available both through the module namespace and as a mixin method),
+      # to provide a constant with a lower-case name.
+      #
+      # @param name [Symbol] the name of the pseudo-constant
+      # @param value [Object] the value of the pseudo-constant
+      # @return [nil]
+      def define_constant name, value
+        if name[0..0] =~ /[A-Z]/
+          const_set name, value # it's just a normal constant
+        else
+          # the pseudo-constant definition is the combination of a method and module_function:
+          define_method(name) { value }
+          module_function name
+        end
+        nil
+      end
+
+    end
+  end
+end

data/lib/mtk/intensity.rb

@@ -0,0 +1,156 @@
+module MTK
+
+  # A measure of intensity, using an underlying value in the range 0.0-1.0
+  class Intensity
+
+    include Comparable
+
+    # The names of the base intensities. See {}MTK::Constants::Intensities} for more info.
+    NAMES = %w[ppp pp p mp mf o ff fff].freeze
+
+    VALUES_BY_NAME = {
+      'ppp' => 0.125,
+      'pp' => 0.25,
+      'p' => 0.375,
+      'mp' => 0.5,
+      'mf' => 0.625,
+      'o' => 0.75,
+      'ff' => 0.875,
+      'fff' => 1.0
+    }
+
+    @flyweight = {}
+
+    # The number of beats, typically representation as a Rational
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    # Return an Intensity, only constructing a new instance when not already in the flyweight cache
+    def self.[](value)
+      value = value.to_f
+      @flyweight[value] ||= new(value)
+    end
+
+    class << self
+      alias :from_f :[]
+      alias :from_i :[]
+    end
+
+    # Lookup an intensity by name.
+    # This method supports appending '-' or '+' for more fine-grained values.
+    def self.from_s(s)
+      return self[1.0] if s == 'fff+' # special case because "fff" is already the maximum
+
+      name = nil
+      modifier = nil
+      if s =~ /^(\w+)([+-])?$/
+        name = $1
+        modifier = $2
+      end
+
+      value = VALUES_BY_NAME[name]
+      raise ArgumentError.new("Invalid Intensity string '#{s}'") unless value
+
+      value += 1.0/24 if modifier == '+'
+      value -= 1.0/24 if modifier == '-'
+
+      self[value]
+    end
+
+    class << self
+      alias :from_name :from_s
+    end
+
+    # The number of beats as a floating point number
+    def to_f
+      @value.to_f
+    end
+
+    # The numerical value for the nearest whole number of beats
+    def to_i
+      @value.round
+    end
+
+    def to_midi
+      (to_f * 127).round
+    end
+
+    def to_percent
+      (@value * 100).round
+    end
+
+    def to_s
+      "#{to_percent}% intensity"
+    end
+
+    def inspect
+      "#<#{self.class}:#{object_id} @value=#{@value}>"
+    end
+
+    def ==( other )
+      other.is_a? MTK::Intensity and other.value == @value
+    end
+
+    def <=> other
+      if other.respond_to? :value
+        @value <=> other.value
+      else
+        @value <=> other
+      end
+
+    end
+
+    def + intensity
+      if intensity.is_a? MTK::Intensity
+        MTK::Intensity[@value + intensity.value]
+      else
+        MTK::Intensity[@value + intensity]
+      end
+    end
+
+    def -intensity
+      if intensity.is_a? MTK::Intensity
+        MTK::Intensity[@value - intensity.value]
+      else
+        MTK::Intensity[@value - intensity]
+      end
+    end
+
+    def * intensity
+      if intensity.is_a? MTK::Intensity
+        MTK::Intensity[@value * intensity.value]
+      else
+        MTK::Intensity[@value * intensity]
+      end
+    end
+
+    def / intensity
+      if intensity.is_a? MTK::Intensity
+        MTK::Intensity[to_f / intensity.value]
+      else
+        MTK::Intensity[to_f / intensity]
+      end
+    end
+
+    def coerce(other)
+      return MTK::Intensity[other], self
+    end
+
+  end
+
+  # Construct a {Duration} from any supported type
+  def Intensity(*anything)
+    anything = anything.first if anything.length == 1
+    case anything
+      when Numeric then MTK::Intensity[anything]
+      when String, Symbol then MTK::Intensity.from_s(anything)
+      when Intensity then anything
+      else raise "Intensity doesn't understand #{anything.class}"
+    end
+  end
+  module_function :Intensity
+
+end

data/lib/mtk/interval.rb

@@ -0,0 +1,155 @@
+module MTK
+
+  # A measure of intensity, using an underlying value in the range 0.0-1.0
+  class Interval
+
+    include Comparable
+
+    # The preferred names of all pre-defined intervals
+    NAMES = %w[P1 m2 M2 m3 M3 P4 TT P5 m6 M6 m7 M7 P8].freeze
+
+    # All valid names of pre-defined intervals, indexed by their value.
+    NAMES_BY_VALUE =
+      [ #   names      # value # description
+        %w( P1 p1 ),   #   0   #  unison
+        %w( m2 min2 ), #   1   #  minor second
+        %w( M2 maj2 ), #   2   #  major second
+        %w( m3 min3 ), #   3   #  minor third
+        %w( M3 maj3 ), #   4   #  major third
+        %w( P4 p4 ),   #   5   #  perfect fourth
+        %w( TT tt ),   #   6   #  tritone (AKA augmented fourth, diminished fifth)
+        %w( P5 p5 ),   #   7   #  perfect fifth
+        %w( m6 min6 ), #   8   #  minor sixth
+        %w( M6 maj6 ), #   9   #  major sixth
+        %w( m7 min7 ), #  10   #  minor seventh
+        %w( M7 maj7 ),  #  11   #  major seventh
+        %w( P8 p8 )    #  12   #  octave
+      ].freeze
+
+    # A mapping from intervals names to their value
+    VALUES_BY_NAME = Hash[ # a map from a list of name,value pairs
+        NAMES_BY_VALUE.map.with_index do |names,value|
+          names.map{|name| [name,value] }
+        end.flatten(1)
+    ].freeze
+
+    # All valid interval names
+    ALL_NAMES = NAMES_BY_VALUE.flatten.freeze
+
+
+    @flyweight = {}
+
+    # The number of semitones represented by this interval
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    # Return an {Interval}, only constructing a new instance when not already in the flyweight cache
+    def self.[](value)
+      value = value.to_f unless value.is_a? Fixnum
+      @flyweight[value] ||= new(value)
+    end
+
+    class << self
+      alias :from_f :[]
+      alias :from_i :[]
+    end
+
+    # Lookup an interval duration by name.
+    def self.from_s(s)
+      value = VALUES_BY_NAME[s.to_s]
+      raise ArgumentError.new("Invalid Interval string '#{s}'") unless value
+      self[value]
+    end
+
+    class << self
+      alias :from_name :from_s
+    end
+
+    # The number of semitones as a floating point number
+    def to_f
+      @value.to_f
+    end
+
+    # The numerical value for the nearest whole number of semitones in this interval
+    def to_i
+      @value.round
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+    def inspect
+      "#{self.class}<#{to_s} semitones>"
+    end
+
+    def ==( other )
+      other.is_a? MTK::Interval and other.value == @value
+    end
+
+    def <=> other
+      if other.respond_to? :value
+        @value <=> other.value
+      else
+        @value <=> other
+      end
+    end
+
+    def + interval
+      if interval.is_a? MTK::Interval
+        MTK::Interval[@value + interval.value]
+      else
+        MTK::Interval[@value + interval]
+      end
+    end
+
+    def -interval
+      if interval.is_a? MTK::Interval
+        MTK::Interval[@value - interval.value]
+      else
+        MTK::Interval[@value - interval]
+      end
+    end
+
+    def * interval
+      if interval.is_a? MTK::Interval
+        MTK::Interval[@value * interval.value]
+      else
+        MTK::Interval[@value * interval]
+      end
+    end
+
+    def / interval
+      if interval.is_a? MTK::Interval
+        MTK::Interval[to_f / interval.value]
+      else
+        MTK::Interval[to_f / interval]
+      end
+    end
+
+    def -@
+      MTK::Interval[@value * -1]
+    end
+
+    def coerce(other)
+      return MTK::Interval[other], self
+    end
+
+  end
+
+  # Construct a {Duration} from any supported type
+  def Interval(*anything)
+    anything = anything.first if anything.length == 1
+    case anything
+      when Numeric then MTK::Interval[anything]
+      when String, Symbol then MTK::Interval.from_s(anything)
+      when Interval then anything
+      else raise "Interval doesn't understand #{anything.class}"
+    end
+  end
+  module_function :Interval
+
+end

data/lib/mtk/lang/mtk_grammar.citrus

@@ -1,44 +1,175 @@
 grammar MTK_Grammar
-  include MTK
 
-  rule pitch_sequence
-    ( pitch (space pitch)* ) {
-      Pattern.PitchSequence *captures[:pitch].map{|p| p.value }
+  rule root
+    ( space? root:(bare_sequencer | sequencer | timeline) space? ) {
+      root.value
     }
   end
 
+  rule bare_sequencer
+    ( pattern '' ) {
+      # it seems at least 2 elements are needed to access the pattern submatch,
+      # so using an empty string as a workaround
+      MTK::Sequencers.LegatoSequencer pattern.value
+    }
+  end
+
+  rule sequencer
+    ( left_curly bare_sequencer right_curly ) {
+      bare_sequencer.value
+    }
+  end
+
+  rule timeline
+    ( left_curly timepoint pattern (space timepoint pattern)* right_curly ) {
+      MTK::Timeline.from_a values_of(:timepoint).zip(values_of :pattern)
+    }
+  end
+
+  rule pattern
+    ( pattern:(bare_choice | choice) '' ) {
+      val = first.value
+      if val.is_a? MTK::Patterns::Pattern then val else MTK::Patterns::Pattern.new [val] end
+    }
+  end
+
+
+  rule bare_choice
+    (
+      seq:(bare_sequence | sequence) (pipe seq:(bare_sequence | sequence))*
+    )
+    {
+      vals = values_of :seq
+      if vals.length==1 then vals[0] else MTK::Patterns.Choice(*vals) end
+    }
+  end
+
+
+  rule choice
+    (
+      left_angle bare_choice right_angle
+    )
+    {
+      bare_choice.value
+    }
+  end
+
+
+  rule bare_sequence
+    (
+      chain (space chain)*
+    )
+    {
+      vals = values_of :chain
+      if vals.length==1 then vals[0] else MTK::Patterns.Sequence(*vals) end
+    }
+  end
+
+
+  rule sequence
+    (
+      left_paren chain (space chain)* right_paren ('*' max_cycles:int)? ('&' element_count:int)?
+    )
+    {
+      chains = values_of(:chain)
+      options = {}
+      if element_count
+        options[:min_elements] = options[:max_elements] = element_count.value
+      end
+      options[:max_cycles] = max_cycles.value if max_cycles
+      if chains.length == 1 and options.empty?
+        chains[0] # Don't form a chain unnecessarily
+      else
+        MTK::Patterns::Sequence.new chains, options
+      end
+    }
+  end
+
+
+  rule foreach
+    (
+      sequence ('@' sequence)+
+    )
+    {
+      MTK::Patterns::ForEach.new(values_of :sequence)
+    }
+  end
+
+
+  rule chain
+    ( chainable (':' chainable)* ) {
+      vals = values_of(:chainable)
+      vals.length == 1 ? vals[0] : MTK::Patterns.Chain(*vals)
+    }
+  end
+
+  rule chainable
+    ( foreach | choice | sequence | element )
+  end
+
+  rule element
+    (
+      elem:( intensity | duration | interval | pitch | pitch_class | variable ) ('*' max_cycles:int)?
+    )
+    {
+      if max_cycles
+        MTK::Patterns::Sequence.new( [elem.value], max_cycles: max_cycles.value )
+      else
+        elem.value
+      end
+    }
+  end
+
+#  rule chord
+#    ( left_bracket pitch (space pitch)* right_bracket ) {
+#      MTK::Chord *values_of(:pitch)
+#    }
+#  end
+
   rule pitch
     ( pitch_class int ) {
-      Pitch[pitch_class.value, int.value]
+      MTK::Pitch[pitch_class.value, int.value]
     }
   end
 
   rule pitch_class
     ( [A-Ga-g] [#b]*2 ) {
-      PitchClass[to_s]
+      MTK::PitchClass[to_s]
     }
   end
 
   rule interval
-    ( 'P' [1458] | [Mm] [2367] | 'TT' ) {
-      Intervals[to_s]
+    ( [Pp] [1458] | ('maj'|'min'|[Mm]) [2367] | 'TT' | 'tt' ) {
+      MTK::Interval.from_s(to_s)
     }
   end
 
   rule intensity
-    ( ('p'1*3 | 'mp' | 'mf' | 'f'1*3) ('+'|'-')? ) {
-      Intensities[to_s]
+    ( ('p'1*3 | 'mp' | 'mf' | 'o' | 'f'2*3) ('+'|'-')? ) {
+      MTK::Intensity.from_s(to_s)
     }
   end
 
   rule duration
-    ( [whqesrx] ('.'|'t')* ) {
-      Durations[to_s]
+    ( rest:'-'? multiplier:number? [whqisrx] ('.'|'t')* ) {
+      MTK::Duration.from_s(to_s)
+    }
+  end
+
+  rule variable
+    ( '$'+ ) {
+      MTK::Variable.new(to_s)
+    }
+  end
+
+  rule timepoint
+    ( number right_arrow ) {
+      number.value
     }
   end
 
   rule number
-    float | int
+    float | rational | int
   end
 
   rule float
@@ -47,12 +178,58 @@ grammar MTK_Grammar
     }
   end
 
+  rule rational
+    ( numerator:int '/' denominator:[0-9]+ ) {
+      Rational(numerator.value, denominator.to_i)
+    }
+  end
+
   rule int
     ( '-'? [0-9]+ ) {
       to_i
     }
   end
 
+  rule left_paren
+    ( '(' space? ) { nil }
+  end
+
+  rule right_paren
+    ( space? ')' ) { nil }
+  end
+
+  rule left_bracket
+    ( '[' space? ) { nil }
+  end
+
+  rule right_bracket
+    ( space? ']' )  { nil }
+  end
+
+  rule left_curly
+    ( '{' space? ) { nil }
+  end
+
+  rule right_curly
+    ( space? '}' ) { nil }
+  end
+
+  rule left_angle
+    ( '<' space? ) { nil }
+  end
+
+  rule right_angle
+    ( space? '>' )  { nil }
+  end
+
+  rule pipe
+    ( space? '|' space? ) { nil }
+  end
+
+  rule right_arrow
+    ( space? '=>' space? ) { nil }
+  end
+
   rule space
     [\s]+ { nil }
   end