brevity 0.4.0

data/lib/brevity/read_file.rb

@@ -0,0 +1,18 @@
+module Brevity
+  class FileParseError < RuntimeError; end;
+  
+  def self.read_file fname
+    cmd_nodes = []
+    ::File.open(fname) do |f|
+      fparser = FileParser.new
+      fnode = fparser.parse(f.read)
+      if fnode.nil?
+        raise FileParseError, fparser.failure_reason
+      end
+      
+      cmd_nodes = fnode.command_nodes
+    end
+    
+    return cmd_nodes
+  end
+end

data/lib/brevity/score_maker.rb

@@ -0,0 +1,64 @@
+module Brevity
+  class MissingStartTempoError < RuntimeError; end
+  class MissingStartMeterError < RuntimeError; end
+  
+  class ScoreMaker
+    include Commands
+    
+    def reset_env
+      @env = {}
+      @env[ENV_START_TEMPO] = nil
+      @env[ENV_TEMPO_CHANGES] = {}
+      @env[ENV_METER_CHANGES] = {}
+      @env[ENV_EXPRS] = {}
+      @env[ENV_PARTS] = {}
+    end
+    
+    def process_nodes cmd_nodes
+      self.reset_env
+      
+      cmd_nodes.each do |cmd_node|
+        cmd_method = cmd_node.name.to_sym
+        self.send(cmd_method,*cmd_node.args)
+      end
+    end
+    
+    def make_score
+      start_tempo = @env[ENV_START_TEMPO]
+      start_meter = @env[ENV_START_METER]\
+                    
+      unless start_tempo.is_a? Numeric
+        raise MissingStartTempoError
+      end
+      
+      unless start_meter.is_a? Music::Transcription::Meter
+        raise MissingStartMeterError
+      end
+      
+      tcs = @env[ENV_TEMPO_CHANGES]
+      mcs = @env[ENV_METER_CHANGES]
+      parts = @env[ENV_PARTS]
+      
+      ## now that start tempo is established, find tempo changes
+      ## whose value is not a Tempo object and convert them
+      #prev_tempo = start_tempo
+      #tcs.keys.sort.each do |offset|
+      #  tc = tcs[offset]
+      #  tempo = tc.value
+      #  if tempo.beat_duration.nil?
+      #    tc.value = Music::Transcription::Tempo.new(
+      #      tempo.beats_per_minute,prev_tempo.beat_duration)
+      #  end
+      #  prev_tempo = tc.value
+      #end
+      
+      return Music::Transcription::Score.new(
+        start_meter,
+        start_tempo,
+        parts: parts,
+        tempo_changes: tcs,
+        meter_changes: mcs
+      )
+    end
+  end
+end

data/lib/brevity/version.rb

@@ -0,0 +1,4 @@
+module Brevity
+  # Brevity version
+  VERSION = "0.4.0"
+end

data/lib/brevity.rb

@@ -0,0 +1,53 @@
+require 'treetop'
+require 'music-transcription'
+
+require 'brevity/version'
+require 'brevity/itemization'
+
+require 'brevity/parsing/numbers/nonnegative_integer'
+require 'brevity/parsing/numbers/positive_integer'
+
+require 'brevity/parsing/note/accent'
+require 'brevity/parsing/note/pitch'
+require 'brevity/parsing/note/pitch_node'
+require 'brevity/parsing/note/link'
+require 'brevity/parsing/note/link_node'
+require 'brevity/parsing/note/duration'
+require 'brevity/parsing/note/duration_nodes'
+require 'brevity/parsing/note/note'
+require 'brevity/parsing/note/note_nodes'
+
+require 'brevity/parsing/modifiers/duplicate_modifier'
+require 'brevity/parsing/modifiers/duplicate_modifier_node'
+require 'brevity/parsing/modifiers/stretch_modifier'
+require 'brevity/parsing/modifiers/stretch_modifier_node'
+require 'brevity/parsing/modifiers/transpose_modifier'
+require 'brevity/parsing/modifiers/transpose_modifier_node'
+require 'brevity/parsing/modifiers/modifier'
+
+require 'brevity/parsing/expression/dynamic'
+require 'brevity/parsing/expression/dynamic_nodes'
+require 'brevity/parsing/expression/gradual'
+require 'brevity/parsing/expression/gradual_node'
+require 'brevity/parsing/expression/label'
+require 'brevity/parsing/expression/label_node'
+require 'brevity/parsing/expression/sequence'
+require 'brevity/parsing/expression/sequence_node'
+require 'brevity/parsing/expression/expression'
+require 'brevity/parsing/expression/expression_nodes'
+
+require 'brevity/parsing/file/comment'
+require 'brevity/parsing/file/comment_node'
+require 'brevity/parsing/file/command'
+require 'brevity/parsing/file/command_node'
+require 'brevity/parsing/file/file'
+require 'brevity/parsing/file/file_node'
+
+require 'brevity/commands/constants'
+require 'brevity/commands/meter'
+require 'brevity/commands/tempo'
+require 'brevity/commands/expr'
+require 'brevity/commands/part'
+
+require 'brevity/read_file'
+require 'brevity/score_maker'

data/manuals/brevity.tex

@@ -0,0 +1,273 @@
+\documentclass{scrartcl}
+\usepackage{url}
+\usepackage{subfig}
+
+\begin{document}
+
+\author{James Tunnell}
+\title{brevity\\
+\begin{LARGE}
+Synatx Guide
+\end{LARGE}}
+\maketitle
+\tableofcontents
+
+\section{Introduction}
+\verb|brevity| is a music notation syntax that aims to be simple, compact, human-readable, and human-editable. A \verb|brevity| file consists of commands and expressions.
+
+\section{Command Syntax}
+Commands in \verb|brevity| look just like commands in \LaTeX. First, a command starts with a backslash '\verb|\|' followed by the command name. Command names consist only of lowercase letters (examples: \verb|\float|, \verb|\exercise|). Then, if the command takes arguments, they are passed in by a series of open-close curly braces '\verb|{}|'. Here is an example command that takes two arguments:
+
+\begin{tabbing}
+  \hspace{0.5in}\= \verb|\step{left}{right}|
+\end{tabbing}
+
+\section{Expression Syntax}
+An expression is a series of space-separated music elements or subexpressions. Expressions containing notes have non-zero duration.
+
+\section{Note and Rests}
+The basic units of a score are the notes and rests, because they define how time is broken up and what should happen during each time chunk. For a rest, of course, nothing should happen. 
+
+In brevity, notes and rests both define a duration, and a note additionally define a number of pitches to be played for the duration. So a rest is really just a note where no pitches are given to play. Of course, multiple pitches mean a note is really a chord.
+attached
+\subsection{Syntax Overview}
+The syntax for a single note or rest is shown below, where the number of pitches can be zero or more.
+\begin{center}
+\framebox{D} \framebox{\framebox{P} \framebox{L} , \framebox{P} \framebox{L} , \ldots} \framebox{A} 
+\end{center}
+\begin{tabbing}
+  \hspace{1.85in}\= D: duration \\
+  \> P: pitch \\
+  \> L: link \\
+  \> A: accent \\
+\end{tabbing}
+To make a sequence of notes/rests, simply string notes together, separated by spaces.
+
+\subsection{Durations}
+Notes and rests both need to declare some duration. Duration is represented by a rational number (i.e. a fraction), as in '3/4' or '2/3'. The numerator can be omitted, as in '/4', and then a 1 is assumed. This is convenient for quarter notes, eight notes, etc. Or, the denominator (and forward-slash) can be omitted, as in '1/' or '1' for a whole note.
+
+\subsection{Pitches}
+Every note can have zero or more pitches attached to it (of course, zero pitches would make the note a rest). Each pitch is given by two components: pitch class and octave. Pitch class is represented by a letter from \verb|A| to \verb|G| and an optional \verb|#| (sharp) or \verb|b| (flat). Following the pitch class, the octave is given, represented by a single decimal digit (\verb|0| to \verb|9|). For example: '\verb|C4|', '\verb|Eb2|', and '\verb|F#5|'.
+
+\subsection{Accents}
+Accents control the duration of a note and the shape of note loudness (like the envelope of a signal). Accents are represented by a single character placed at the end of the note body, after all the pitches and links. Simply omit the accent character to place a note without any accent.
+
+The supported accent types and the characters used to represent them are summarized in Table~\ref{tab:accent_characters}. A short description of the effect of each accent type follows:
+\begin{itemize}
+	\item Staccato: separated from next note
+	\item Staccatissimo: very separated from next note
+	\item Accent (marcato): emphasize beginning and then taper off rather quickly
+	\item Martellato (hammered): loud as an accent mark and short as a staccato
+	\item Tenuto: Played at full length or longer. When under a slur, note is separated with a little space from surrounding notes
+\end{itemize}
+
+\begin{table}[ht]
+\begin{center}
+  \begin{tabular}{ l | l }
+    \hline
+    \textbf{Accent type} & \textbf{Marker} \\ \hline
+    Staccato & \verb|.| \hspace{.1cm} period \\ \hline
+    Staccatissimo & \verb|'| \hspace{.1cm} apostrophe \\ \hline
+    Accent (marcato) & \verb|>| \hspace{.1cm} greater than \\ \hline
+    Martellato (hammered) & \verb|^| \hspace{.1cm} caret \\ \hline
+    Tenuto (sustained) & \verb|_| \hspace{.1cm} underscore \\ \hline
+    \hline
+  \end{tabular}
+\end{center}
+\caption{Accent types and markers}
+\label{tab:accent_characters}
+\end{table}
+
+As an example, some stocatto notes:
+\begin{center}
+\verb|/4C5. /4D5. /4E5.|
+\end{center}
+
+\subsection{Relationships}
+Note relationships (or links) control the transition between sequential notes. A link is just between two notes, and won't have any other effect outside those notes. A link marker is placed just after a note pitch. Here is an example of a passage connected by slurs:
+\begin{center}
+\verb|/4C4=C4 /16C4=E4 /16E4=F4 /4F4|
+\end{center}
+Here is an example using slur/tie links:
+\begin{center}
+\verb|/4C4=C4 /16C4=E4,F4=G4 /16E4,G4|
+\end{center}
+Table~\ref{tab:link_markers} lists the supported link types and the characters used to represent them. Here is a description of each supported link type:
+\begin{itemize}
+\item Slur/tie: connects two pitches with no separation and no rearticulation. The same link marker is used for a slur or tie since they're effectively the same relationship.
+\item Legato: connects two pitches with no separation and with rearticulation.
+\item Glissando: connect two pitches by articulating all the pitches in between.
+\item Portamento: continuously glide between pitches, without rearticulation.
+\end{itemize}
+\begin{table}[ht]
+\begin{center}
+  \begin{tabular}{ l | l}
+    \hline
+    \textbf{Link type} & \textbf{Marker} \\ \hline
+    Slur/Tie & \verb|=| \hspace{.1cm} equals \\ \hline
+    Legato & \verb|-| \hspace{.1cm} minus \\ \hline
+    Glissando & \verb|~| \hspace{.1cm} tilde \\ \hline
+    Portamento & \verb|/| \hspace{.1cm} forward-slash \\ \hline
+    \hline
+  \end{tabular}
+\end{center}
+\caption{Link types and markers}
+\label{tab:link_markers}
+\end{table}
+
+\section{Sequences}
+A sequence is a series of notes/rests. A sequence is declared by placing notes/rests together and separating by spaces, as in 
+\begin{tabbing}
+  \hspace{0.5in}\= \verb|/4D6 /4A5 /16Ab6 3/16Bb6=Bb6 /4Bb6|
+\end{tabbing}
+
+A sequence can either be labeled for later reused, or modified to produce a new sequence.
+
+\subsection{Labeling Sequences}
+Sequences are assigned to a label using a \verb|\beginsequence| statement, followed by a a note sequence, as in
+\begin{tabbing}
+  \hspace{0.5in}\= \verb|\expr{my_label}{/8C5 /8D5 /8E5 /8D5 /2C5}|
+\end{tabbing}
+
+Once labeled, the label can be used in place of the sequence. 
+
+\subsubsection{Continuing Labeled Sequences}
+A labeled sequence can be continued later, which will add more notes onto the end of the sequence. This might also be called concatenation.
+
+A labeled sequence is continued using a \verb|\expr| statement, as in
+\begin{tabbing}
+  \hspace{0.5in}\= \verb|\expr{bass}{ /8C4 /8C4 /8C4 /8C4 }| \\
+  \> \verb|\expr{bass}{ /8E4 /8E4 /8E4 /8E4 }|
+\end{tabbing}
+
+This allows a sequence to span over multiple lines by starting each line with the same label. But continuing lines do not have to be consecutive, as long as the same label is used for each continuing line. So, multiple parts can be interleaved as follows:
+\begin{tabbing}
+  \hspace{1in}\= \verb| \expr{bass}{ /4C4 /4C4 /4C4 /4C4 }| \\
+  \> \verb| \expr{lead}{ /2E6 /2E6 }| \\
+  \> ~\\
+  \> \verb| \expr{bass}{ /4E4 /4E4 /4E4 /4E4 }| \\
+  \> \verb| \expr{lead}{ /2G6 /2G6 }| \\
+\end{tabbing}
+
+\subsection{Modifying Sequences}
+Sequences can be modified, which results in a new sequence. If a sequence is not labeled, it needs to be grouped using parentheses before it can be modified, as in 
+\begin{center}
+\verb|( /4C5 /4D5 )|
+\end{center}
+
+Sequences can be duplicated, transposed, stretched, and composed. Additionally, sequence modifications can be chained one right after the other.
+
+\subsubsection{Duplicating Sequences}
+A sequence can be replaced some number of duplicate sequences by following it with \verb|:n|, where $n$ indicates the number of duplicates.
+
+For example, to replace a sequence with $2$ duplicate sequences (i.e., repeat once),
+\begin{center}
+\verb|( /8C5 /8C#5 ):2| \ is equivalent to \verb|/8C5 /8C#5 /8C5 /8C#5|
+\end{center}
+
+\subsubsection{Transposing Sequences}
+A sequence can be transposed by appending a +/- and some number of semitones (half-steps) to transpose by. For example, to transpose up four semitones:
+\begin{center}
+\verb| ( /4C5 /4D5 )+4| \ would yield \verb|/4E5 /4F#5|
+\end{center}
+
+Or, to transpose down by four semitones: 
+\begin{center}
+\verb| ( /4C5 /4D5 )-4| \ would yield \verb|/4Ab4 /4Bb4|
+\end{center}
+The result is the sequence transposed up/down some number of semitones.
+
+\subsubsection{Stretching Sequences}
+Sequences can be stretched in two ways: stretching to equal some given total duration, or stretching by multiplying all note durations by some factor.
+
+\paragraph{Stretching to equal some duration}~\\
+To stretch so that total note duration equals some given note duration. This is done by following a sequence with \verb|:r|, where $r$ is some note duration.
+
+For example, to turn a sequence of two quarter notes into two half notes,
+\begin{center}
+\verb| ( /4C5 /4D5 )=1| \ is equivalent to \verb|/2C5 /2D5|
+\end{center}
+
+Or to make a half note triplet from three quarter notes,
+\begin{center}
+\verb| ( /4A4 /4B4 /4C4 )=/2| \ is equivalent to \verb|/6A4 /6B4 /6C4|
+\end{center}
+
+If the sequence contains notes of different durations, each note keeps the same ratio to total duration. For example,
+\begin{center}
+\verb| ( /2Eb5 /4Bb5 3/4Bb5 )=1| \ is equivalent to \verb| /3Eb5 /6Bb5 /2Bb5|
+\end{center}
+
+\paragraph{Stretching by multiplying note durations}~\\
+A sequence can be stretched by multiplying the note durations by some multiplicative factor. This is done by following a sequence with \verb|*r|, where $r$ is some rational number, that can be formatted just like a note duration.
+
+For example, to multiply durations by 2,
+\begin{center}
+\verb| ( /4C5 /4D5 /2E5 )*2| \ is equivalet to \verb|/2C5 /2D5 1E5|
+\end{center}
+
+\subsubsection{Composing Sequences}
+Sequences can be composed together to create a new sequence. This is done implicitly just by following one sequence with more notes or sequences. 
+
+For example, 
+\begin{center}
+\verb|(/4A5 /4C5):2 1Eb5| \ would be equivalent to \verb|/4A5 /4C5 /4A5 /4C5 1Eb5|
+\end{center}
+
+Of course, labels can be used in places of sequences, as in
+\begin{tabbing}
+  \hspace{1in}\= \verb|\expr{seq1}{ /4F4 /4G4 }| \\
+  \> \verb|\expr{seq2}{ seq1:2 seq1+2 }|
+\end{tabbing}
+
+\subsubsection{Chaining Modifications}
+Sequence modifications can be chained, so each modification is applied on the new sequence resulting from the previous modification. For example,
+\begin{center}
+\verb|(/4F4 /4G4)+2:2| \ is equivalent to \verb|/4G4 /4A4 /4G4 /4A4|
+\end{center}
+
+\section{Dynamics}
+Dynamics is concerned with absolute base loudness over an entire part. This is in contrast to note accents which affect the relative loudness shape of a single note. Dynamic levels are represented by markers which you might expect: \verb|ppp|, \verb|pp|, \verb|p|, \verb|mp|, \verb|mf|, \verb|f|, \verb|ff|, and \verb|fff|.
+
+\subsection{Immediate Changes}
+To immediately change dynamic level, simply place a dynamic marker by itself before a note. The change will take effect immediately at the start of the note. Here is an example of an immediate dynamic change: \begin{center}
+\verb| p /8C6 /8C6 /4F6 f /8D6 /8D6 /4G6 |
+\end{center}
+
+\subsection{Gradual Changes}
+Dynamic level can be gradually changed over time with a crescendo or decrescendo. By preceding the dynamic level with a \verb|<| or \verb|>|, change will be marked as a gradual change from whatever the previous dynamic level was. Here is an example of a gradual dynamic change:
+\begin{center}
+\verb| p /8C6 /8C6 /4F6 <f /8D6 /8D6 /4G6 |
+\end{center}
+
+\section{Scores}
+The final goal of the music notation file is to compose a score, which has one or more parts. All of the parts declared anywhere in the file will be added to the score. Besides at least one part, the only other information that is required is a starting tempo. The following subsections cover parts and starting tempo.
+
+\subsection{Parts}
+A \verb|\part| statement associates a name with a musical part. The part consists of: start dynamic, dynamic changes, and notes. The start dynamic is given as a separate parameter, and the dynamic changes and notes are given together in the expression parameter.
+
+Here is an example of the syntax:
+
+\begin{tabbing}
+  \hspace{0.5in}\= \verb|\part{Lead Guitar}{mf}{/8D5 /8Eb5 /4F5 3/4C5}|
+\end{tabbing}
+
+Notice in the example there is a starting dynamic level, mezzo forte, just before the note sequence. Here is another example, this time using labeled expressions:
+
+\begin{tabbing}
+  \hspace{0.5in}\= \verb|\part{Piano}{pp}{sectA sectB:2 sectA}| \\
+\end{tabbing}
+
+Parts can be declared anywhere in the file, and they will be added to the score.
+
+\subsection{Starting Tempo}
+A starting tempo is defined by a \verb|\starttempo| statement, which can be placed anywhere in the file. The tempo given must inculde the beat duration. Here is an example, with a tempo of 120 bpm and a quarter note beat duration:
+
+\begin{tabbing}
+  \hspace{0.5in}\= \verb|\starttempo{@120,/4}|
+\end{tabbing}
+
+\section{Comments}
+Any line starting with a number sign `\verb|#|' will be considered a comment and ignored.
+
+\end{document}

data/spec/brevity_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'brevity'
+
+describe Brevity do
+  it "should have a VERSION constant" do
+    subject.const_get('VERSION').should_not be_empty
+  end
+end

data/spec/commands/expr_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Commands.expr' do
+  before :each do
+    @tester = CommandTester.new
+  end
+  
+  context 'given valid expression' do
+    it 'should assign primitives to given label under @env[ENV_EXPRS]' do
+      tgt = [ Note::Half.new([C2]), Note::Half.new, Note::Quarter.new([E2]) ]
+      @tester.expr("hello","/2C2 /2 /4D2+2")
+      @tester.env[Commands::ENV_EXPRS]["hello".to_sym].should eq(tgt)
+    end
+  end  
+end

data/spec/commands/meter_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Commands.meter' do
+  before :each do
+    @tester = CommandTester.new
+  end
+  
+  context 'given valid beats per measure and beat dur strings' do
+    it 'should assign tempo to @env[ENV_START_METER]' do
+      @tester.meter("4","1/4")
+      @tester.env[Commands::ENV_START_METER].should eq(Meter.new(4,"1/4".to_r))
+    end
+  end
+  
+  context 'given an invalid bpm or beatdur string' do
+    it 'should raise ArgumentError' do
+      expect { @tester.meter("4.5","1/4") }.to raise_error ArgumentError
+      expect { @tester.meter("4","1/4.2") }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/commands/part_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Commands.part' do
+  before :each do
+    @tester = CommandTester.new
+  end
+  
+  context 'given valid expression' do
+    it 'should assign primitives to given label under @env[ENV_EXPRS]' do
+      notes = [ Note::Half.new([C2]), Note::Half.new, Note::Quarter.new([E2]) ]
+      tgt = Part.new(notes: notes, dynamic_profile: Profile.new(Dynamics::MF))
+      @tester.part("hello","mf","/2C2 /2 /4D2+2")
+      @tester.env[Commands::ENV_PARTS]["hello"].should eq(tgt)
+    end
+  end  
+end

data/spec/commands/tempo_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Commands.tempo' do
+  before :each do
+    @tester = CommandTester.new
+  end
+  
+  context 'given valid bpm and beatdur strings' do
+    it 'should assign tempo to @env[ENV_START_TEMPO]' do
+      @tester.tempo("120")
+      @tester.env[Commands::ENV_START_TEMPO].should eq(120)
+    end
+  end
+  
+  context 'given an invalid bpm or beatdur string' do
+    it 'should raise ArgumentError' do
+      expect { @tester.tempo("120.5") }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/itemization_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Itemization do
+  describe '#initialize' do
+    it 'should calculate duration from notes' do
+      {
+        [] => 0,
+        [ Note::Quarter.new ] => "1/4".to_r,
+        [ Note::Quarter.new, Note::Half.new ] => "3/4".to_r,
+      }.each do |notes,tgt|
+        Itemization.new(notes: notes).duration.should eq(tgt)
+      end
+    end
+  end
+  
+  describe '#append!' do
+    before :all do
+      @a = Itemization.new(
+        notes: [ Note::Half.new, Note::Half.new ]
+      )
+      @b_start_dyn_change = Change::Immediate.new(Dynamics::PPP)
+      @b = Itemization.new(
+        dynamic_changes: { 0.to_r => @b_start_dyn_change },
+        notes: [ Note::Quarter.new, Note::Quarter.new ]
+      )
+      @c = @a.append @b
+    end
+    
+    it 'should append notes from given other' do
+      @c.notes.size.should eq(@a.notes.size + @b.notes.size)
+    end
+    
+    it 'should add durations' do
+      @c.duration.should eq(@a.duration + @b.duration)
+    end
+    
+    it 'should insert dynamic changes from given other, with offset' do
+      @c.dynamic_changes.should have_key(@a.duration)
+      @c.dynamic_changes[@a.duration].should eq(@b_start_dyn_change)
+    end
+    
+    it 'should insert tempo changes from given other, with offset' do
+      
+    end
+  end
+end

data/spec/parsing/expression/dynamic_nodes_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe DynamicNode do
+  {
+    "ppp" => Dynamics::PPP,
+    "pp" => Dynamics::PP,
+    "p" => Dynamics::P,
+    "mp" => Dynamics::MP,
+    "mf" => Dynamics::MF,
+    "f" => Dynamics::F,
+    "ff" => Dynamics::FF,
+    "fff" => Dynamics::FFF,
+  }.each do |str, tgt|
+    parser = DynamicParser.new
+    res = parser.parse(str)
+    
+    it "should parse as DynamicNode" do
+      res.should be_a DynamicNode
+    end
+    
+    describe '#to_dynamic' do
+      d = res.to_dynamic
+      it 'should produce a Dynamic' do
+        d.should be_a Dynamic
+      end
+      
+      it 'should produce a value matching input str' do
+        d.should eq tgt
+      end
+    end
+  end
+end

data/spec/parsing/expression/dynamic_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe DynamicParser do
+  before :all do
+    @parser = DynamicParser.new
+  end
+  
+  context 'valid dynamic level' do
+    it 'should parse' do
+      ["ppp","pp","p","mp","mf","f","ff","fff"].each do |dynamic_level|
+        @parser.parse(dynamic_level).should_not be nil
+      end
+    end
+  end
+
+  context 'invalid dynamic level' do
+    it 'should not parse' do
+      ["pf","fp"].each do |dynamic_level|
+        @parser.parse(dynamic_level).should be nil
+      end
+    end
+  end
+end