jmtk 0.0.3.3-java

data/lib/mtk/lang/mtk_grammar.citrus

@@ -0,0 +1,237 @@
+grammar MTK_Grammar
+
+  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::Events::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::Sequence.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::Groups::Chord *values_of(:pitch)
+#    }
+#  end
+
+  rule pitch
+    ( pitch_class int ) {
+      MTK::Core::Pitch[pitch_class.value, int.value]
+    }
+  end
+
+  rule pitch_class
+    ( [A-Ga-g] [#b]*2 ) {
+      MTK::Core::PitchClass[to_s]
+    }
+  end
+
+  rule interval
+    ( [Pp] [1458] | ('maj'|'min'|[Mm]) [2367] | 'TT' | 'tt' ) {
+      MTK::Core::Interval.from_s(to_s)
+    }
+  end
+
+  rule intensity
+    ( ('p'1*3 | 'mp' | 'mf' | 'o' | 'f'2*3) ('+'|'-')? ) {
+      MTK::Core::Intensity.from_s(to_s)
+    }
+  end
+
+  rule duration
+    ( rest:'-'? multiplier:number? [whqisrx] ('.'|'t')* ) {
+      MTK::Core::Duration.from_s(to_s)
+    }
+  end
+
+  rule variable
+    ( '$'+ ) {
+      MTK::Lang::Variable.new(to_s)
+    }
+  end
+
+  rule timepoint
+    ( number right_arrow ) {
+      number.value
+    }
+  end
+
+  rule number
+    float | rational | int
+  end
+
+  rule float
+    ( '-'? [0-9]+ '.' [0-9]+ ) {
+      to_f
+    }
+  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
+
+end

data/lib/mtk/lang/parser.rb

@@ -0,0 +1,29 @@
+require 'citrus'
+
+# @private
+class Citrus::Match
+  def values_of(token_name)
+    captures[token_name].map{|token| token.value }
+  end
+end
+
+Citrus.load File.join(File.dirname(__FILE__),'mtk_grammar')
+
+module MTK
+  module Lang
+
+    # Parser for the {file:lib/mtk/lang/mtk_grammar.citrus MTK grammar}
+    class Parser
+
+      def self.parse(syntax, root=:root, dump=false)
+        syntax = syntax.to_s.strip
+        return nil if syntax.empty?
+        matcher = ::MTK_Grammar.parse(syntax, :root => root)
+        puts matcher.dump if dump
+        matcher.value
+      end
+
+    end
+
+  end
+end

data/lib/mtk/lang/pitch_classes.rb

@@ -0,0 +1,29 @@
+module MTK
+  module Lang
+
+    # Defines a constant for each {PitchClass} in the Western chromatic scale.
+    module PitchClasses
+
+      # The values of all constants defined in this module
+      PITCH_CLASSES = MTK::Core::PitchClass::PITCH_CLASSES
+
+      # The names of all constants defined in this module
+      PITCH_CLASS_NAMES = MTK::Core::PitchClass::NAMES
+
+      PITCH_CLASSES.each { |pc| const_set pc.name, pc }
+
+      # Lookup the value of an pitch class constant by name.
+      # @example lookup value of 'C'
+      #         MTK::Core::PitchClasses['C']
+      # @see Groups::PitchClass.[]
+      def self.[](name)
+        begin
+          const_get name
+        rescue
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/mtk/lang/pitches.rb

@@ -0,0 +1,52 @@
+module MTK
+  module Lang
+
+    # Defines a constants for each {Core::Pitch} in the standard MIDI range using scientific pitch notation.
+    #
+    # See http://en.wikipedia.org/wiki/Scientific_pitch_notation
+    #
+    # @note Because the character '#' cannot be used in the name of a constant,
+    #     the "black key" pitches are all named as flats with 'b' (for example, Gb3 or Cb4)
+    # @note Because the character '-' (minus) cannot be used in the name of a constant,
+    #     the low pitches use '_' (underscore) in place of '-' (minus) (for example C_1).
+    module Pitches
+
+      # The values of all constants defined in this module
+      PITCHES = []
+
+      # The names of all constants defined in this module
+      PITCH_NAMES = []
+
+      128.times do |note_number|
+        pitch = MTK::Core::Pitch.from_i( note_number )
+        PITCHES << pitch
+
+        octave_str = pitch.octave.to_s.sub(/-/,'_') # '_1' for -1
+        name = "#{pitch.pitch_class}#{octave_str}"
+        PITCH_NAMES << name
+
+        # TODO? also define lower case pseudo constants for consistency with the grammar?
+
+        const_set name, pitch
+      end
+
+      PITCHES.freeze
+      PITCH_NAMES.freeze
+
+      # Lookup the value of an pitch constant by name.
+      # @example lookup value of 'C3'
+      #         MTK::Core::Pitches['C3']
+      # @see Core::Pitch.from_s
+      # @note Unlike {Core::Pitch.from_s} this method will accept either '_' (underscore) or '-' (minus) and treat it like '-' (minus)
+      # @note Unlike {Core::Pitch.from_s} this method only accepts the accidental 'b'
+      def self.[](name)
+        begin
+          const_get name.sub('-','_')
+        rescue
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/mtk/lang/pseudo_constants.rb

@@ -0,0 +1,26 @@
+module MTK
+  module Lang
+
+    # 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/lang/variable.rb

@@ -0,0 +1,32 @@
+module MTK::Lang
+
+  # A placeholder element for a variable value, for use within a {Patterns::Pattern} such as a {Patterns::ForEach} pattern.
+  # Will be evaluated to an actual value by the Pattern or Sequencer
+  #
+  class Variable
+
+    attr_reader :name
+
+    attr_accessor :value
+
+    def initialize name, value=nil
+      @name = name
+      @value = value
+      @implicit = !!(name =~ /^\$+$/)
+    end
+
+    # @return true when this variable has no specific value and references the implicit variable stack (such as in a {Patterns::ForEach})
+    def implicit?
+      @implicit
+    end
+
+    def == other
+      other.is_a? self.class and other.name == self.name
+    end
+
+    def to_s
+      "#{self.class}<#{name}#{'='+value.to_s if value}>"
+    end
+  end
+
+end

data/lib/mtk/numeric_extensions.rb

@@ -0,0 +1,66 @@
+# Optional Numeric methods for converting to {MTK::Core} objects.
+#
+# @note you must require 'mtk/numeric_extensions' to use these methods.
+#
+class Numeric
+
+  # Convert a Numeric to a {MTK::Core::Pitch}
+  # @example 60.to_pitch => C4
+  def to_pitch
+    MTK::Core::Pitch.from_f(self)
+  end
+
+
+  # Convert a Numeric to a {MTK::Core::PitchClass}
+  # @example 2.to_pitch_class => D
+  def to_pitch_class
+    MTK::Core::PitchClass.from_f(self)
+  end
+
+
+  # Convert a Numeric to a {MTK::Core::Duration}
+  # @example 3.5.to_duration + 1.beat + 2.beats
+  def to_duration
+    MTK::Core::Duration.from_f(self)
+  end
+  alias beats to_duration
+  alias beat to_duration
+
+
+  # Convert a Numeric to a {MTK::Core::Intensity}
+  # @note The standard range of intensity values is from 0.0 - 1.0
+  # @example 1.to_pitch => fff
+  def to_intensity
+    MTK::Core::Intensity.from_f(self)
+  end
+
+  # Convert a Numeric percentage to a {MTK::Core::Intensity}
+  # @note The standard range of intensity percentages is from 0 - 100
+  # @example 100.percent_intensity => fff
+  def percent_intensity
+    MTK::Core::Intensity.from_f(self/100.0)
+  end
+
+  # Convert a Numeric to a {MTK::Core::Interval}
+  # @example 3.5.to_interval + 1.semitone + 2.semitones
+  def to_interval
+    MTK::Core::Interval.from_f(self)
+  end
+  alias semitones to_interval
+  alias semitone to_interval
+
+  # Convert a Numeric cents value to a {MTK::Core::Interval}
+  # @example 100.cents => 1.semitone
+  def cents
+    MTK::Core::Interval.from_f(self/100.0)
+  end
+  alias cent cents
+
+  # Convert a Numeric octaves value to a {MTK::Core::Interval}
+  # @example 1.octave => 12.semitones
+  def octaves
+    MTK::Core::Interval.from_f(self * 12)
+  end
+  alias octave octaves
+
+end