brevity 0.4.0

data/spec/parsing/expression/expression_nodes_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe ExpressionNode do
+  describe '#primitives' do
+    context 'simple sequence' do
+      it 'should be converted to array of notes' do
+        str = SEQUENCES.keys.last
+        node = EXPR_PARSER.parse(str)
+        
+        tgt = SEQUENCES[str]
+        node.primitives({}).should eq tgt
+      end
+    end
+    
+    context 'composed sequences' do
+      it 'should combine them into a single array' do
+        strA, strB = SEQUENCES.keys[-2..-1]
+        tgt = SEQUENCES[strA].clone + SEQUENCES[strB].clone
+        str = strA + " (#{strB})"
+        EXPR_PARSER.parse(str).primitives({}).should eq tgt
+      end
+    end
+
+    context 'chained modifications' do
+      it 'should produce a single part, applying all modifications in sequence' do
+        str = SEQUENCES.keys.last
+        notes = SEQUENCES[str]
+        str = "(#{str})"
+        MODIFIERS.each do |modtype,modcases|
+          modstrs, modlambdas = modcases.entries.transpose
+          modstr = modstrs.join
+          tgt = notes.clone
+          modlambdas.each {|l| tgt = l.call(tgt) }
+          node = EXPR_PARSER.parse(str + modstr)
+          node.primitives({}).should eq(tgt)
+        end
+      end
+    end
+    
+    context 'with dynamic changes' do
+      it 'should convert dynamic changes to dynamic values and gradual nodes' do
+        {
+          "mp /2 > /2A2 f < /4C4 mp" => [
+            Dynamics::MP, Note::Half.new, GradualParser.new.parse(">"),
+            Note::Half.new([A2]), Dynamics::F, GradualParser.new.parse("<"),
+            Note::Quarter.new([C4]), Dynamics::MP
+          ]
+        }.each do |str,tgt|
+          node = EXPR_PARSER.parse(str)
+          primitives = node.primitives({})
+          primitives.should eq tgt
+        end
+      end
+    end
+  end
+end
+
+describe GroupNode do
+  describe '#primitives' do
+    it 'should produce same array as the string that is in parenthesis' do
+      SEQUENCES.each do |str,tgt|
+        node = EXPR_PARSER.parse(str)
+        node2 = EXPR_PARSER.parse("(#{str})")
+        node.primitives({}).should eq(node2.primitives({}))
+      end
+    end
+  end
+end
+
+describe ModifiableNode do
+  describe '#primitives' do
+    it 'should produce a modified array' do
+      SEQUENCES.each do |seqstr,tgt|
+        MODIFIERS.each do |modtype,modcases|
+          modcases.each do |modstr,modlambda|
+            str = "(#{seqstr})#{modstr}"
+            tgtmod = modlambda.call(tgt)
+            
+            node = EXPR_PARSER.parse str
+            res = node.primitives({})
+            res.should eq tgtmod
+          end
+        end
+      end
+    end
+  end
+end

data/spec/parsing/expression/expression_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe ExpressionParser do
+  context 'single note' do
+    it 'should parse as ExpressionNode' do
+      NOTES.keys.each {|str| EXPR_PARSER.should parse_as(str,ExpressionNode) }
+    end
+  end
+
+  context 'note sequence only' do
+    it 'should parse as ExpressionNode' do
+      SEQUENCES.keys.each {|str| EXPR_PARSER.should parse_as(str,ExpressionNode) }
+    end
+  end
+  
+  context 'grouped note sequence' do
+    it 'should parse as ExpressionNode' do
+      SEQUENCES.keys.each {|str| EXPR_PARSER.should parse_as("(#{str})",ExpressionNode) }
+    end
+  end
+  
+  context 'composed sequences' do
+    it 'should parse as ExpressionNode' do
+      strs = SEQUENCES.keys[0..2]
+      str = "#{strs[0]} (#{strs[1]}) #{strs[2]}"
+      EXPR_PARSER.should parse_as(str,ExpressionNode)
+    end
+  end
+  
+  context 'modified sequence' do
+    context 'labeled sequence' do
+      it 'should parse as ExpressionNode' do
+        MODIFIERS.each do |modtype,cases|
+          cases.keys.each do |modstr,modlambda|
+            str = "#{LABELS[0]}#{modstr}"
+            EXPR_PARSER.should parse_as(str,ExpressionNode)
+          end
+        end
+      end
+    end
+    
+    context 'grouped sequence' do
+      it 'should parse as ExpressionNode' do
+        MODIFIERS.each do |modtype,cases|
+          cases.keys.each do |modstr,modlambda|
+            str = "(#{SEQUENCES.keys.last})#{modstr}"
+            EXPR_PARSER.should parse_as(str,ExpressionNode)
+          end
+        end      
+      end
+    end
+    
+    context 'single note' do
+      it 'should parse as ExpressionNode' do
+        MODIFIERS.each do |modtype,cases|
+          cases.keys.each do |modstr,modlambda|
+            str = "#{NOTES.keys[0]}#{modstr}"
+            EXPR_PARSER.should parse_as(str,ExpressionNode)
+          end
+        end
+      end
+    end
+  end
+  
+  context 'chained modification' do
+    it 'should parse as ExpressionNode' do
+      str = "(#{SEQUENCES.keys.last}):1+2-2=/2*3/2"
+      EXPR_PARSER.should parse_as(str,ExpressionNode)
+    end
+  end
+  
+  context 'with dynamic changes' do
+    it 'should parse as ExpressionNode' do
+      str = "mp /2 > /2A2 f < /4C4 mp"
+      EXPR_PARSER.should parse_as(str,ExpressionNode)
+    end
+  end
+  
+  context 'separated by spaces, tabs, carriage returns, and newlines' do
+    it 'should parse as ExpressionNode' do
+      str = "(mp /2 ppp \n /2) /4 /4 \r\n /4"
+      EXPR_PARSER.should parse_as(str,ExpressionNode)
+    end
+  end
+end

data/spec/parsing/expression/gradual_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe GradualParser do
+  context '> or <' do
+    it 'should parse as GradualNode' do
+      GradualParser.new.should parse_as('>',GradualNode)
+      GradualParser.new.should parse_as('<',GradualNode)
+    end
+  end
+end

data/spec/parsing/expression/label_node_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe LabelNode do
+  describe '#primitives' do
+    it 'should fetch whatever is in given Hash' do
+      LABELS.each do |str|
+        node = LABEL_PARSER.parse(str)
+        tgt = [Note::Quarter.new]
+        node.primitives({ node.to_key => tgt }).should eq tgt
+      end
+    end    
+  end
+end

data/spec/parsing/expression/label_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe LabelParser do
+  context 'alphabetic only' do
+    it 'should parse' do
+      ["abc","HiThere","Yeah","oKAY"].each do |str|
+        LABEL_PARSER.parse(str).should_not be nil
+      end
+    end
+  end
+
+  context 'alphabetic plus numbers (after first char)' do
+    it 'should parse' do
+      ["abc123","HiThere1","C00kieCrisp"].each do |str|
+        LABEL_PARSER.parse(str).should_not be nil
+      end
+    end
+  end
+
+  context 'alphabetic with underscores' do
+    it 'should parse' do
+      ["_okaydokee","looks_good","Hey_There555"].each do |str|
+        LABEL_PARSER.parse(str).should_not be nil
+      end
+    end
+  end
+  
+  context 'non-alphabetic chars' do
+    it 'should not parse' do
+      ["Hey there","what?","yeah."].each do |str|
+        LABEL_PARSER.parse(str).should be nil
+      end
+    end
+  end
+end

data/spec/parsing/file/command_node_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe CommandNode do
+  describe '#name' do
+    it 'should return the given command name' do
+      {
+        '\bake' => 'bake',
+        '\once{}' => 'once',
+        '\dosomething{123}{456}' => 'dosomething'
+      }.each do |str,tgt|
+        node = COMMAND_PARSER.parse(str)
+        node.name.should eq tgt
+      end
+    end
+  end
+  
+  describe '#args' do
+    it 'should return  the strings in braces' do
+      {
+        '\bake' => [],
+        '\once{}' => [''],
+        '\dosomething{123}{456}' => ['123','456']
+      }.each do |str,tgt|
+        node = COMMAND_PARSER.parse(str)
+        node.args.should eq tgt
+      end
+    end
+  end
+end

data/spec/parsing/file/command_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe CommandParser do
+  describe '#parse' do
+    before :all do
+      @parser = CommandParser.new
+    end
+    
+    it 'should parse as a CommandNode' do
+      [ '\bake','\baketwo{}{}','\sandwich{Ham}{Cheese}',
+        '\icecream{Vanilla}{Chocolate Syrup}{sprinkles}',
+        '\gobbledegook{akw4hf&Q(#^$hlka}{::".[p,!!!}'
+      ].each do |str|
+        @parser.should parse_as(str,CommandNode)
+      end
+    end
+  end
+end

data/spec/parsing/file/comment_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe CommentParser do
+  context 'string starts with #' do
+    it 'should parse' do
+      [ "#",
+        "# Hello world",
+        "# This can be anything at all :)"
+      ].each do |str|
+        COMMENT_PARSER.should parse(str)
+      end
+    end
+  end
+end

data/spec/parsing/file/file_node_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe FileNode do
+  describe '#command_nodes' do
+    it 'should return the given command nodes' do
+      cmd_strs = ['\bake','\once{}','\dosomething{123}{456}',"\\seq{abc}{\2 \2 \1C2\n \2 \2}"]
+      cmds = cmd_strs.map{ |str| COMMAND_PARSER.parse(str) }
+      [" ","\n"].each do |sep|
+        str = cmd_strs.join(sep)
+        node = FILE_PARSER.parse(str)
+        command_nodes = node.command_nodes
+        command_nodes.each_index do |i|
+          command_nodes[i].name.should eq cmds[i].name
+          command_nodes[i].args.should eq cmds[i].args
+        end
+      end
+    end
+  end
+end

data/spec/parsing/file/file_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe FileParser do
+  {
+    'commands spanning multiple lines' => (
+        "\t  \\seq{ABC}{\n" + 
+        "\t  /2 /2 /4C2 /4C2 /2\n" + 
+        "\t  /2 /2:2 (/4 /4C4):2\n" + 
+        "\t  }\n" + 
+        "\t  \\seq{DEF}{\n" + 
+        "\t  /4 /4 mylabel}\n" + 
+        "\n"),
+    'commands on same line' => (
+      "\\seq{ABC}{ /2 /4C2 }\\seq{DEF}{ /4C2 /4C2}\\starttempo{120}"
+    ),
+    'expressions, commands, and comments' => (
+      "# This is a comment, everything after is fine!!!\n" + 
+      "\\seq{ABC}{ /2 /4C2} \\seq{DEF}{ /4C2 /4C2}\n" +
+      "# Another comment here\n" + 
+      "\\starttempo{120}\n" + 
+      "# Annnnd, the last word.\n"
+    )
+  }.each do |context_str,str|
+    context context_str do
+      it 'should parse as FileNode' do
+        FILE_PARSER.should parse_as(str,FileNode)
+      end
+    end
+  end
+end

data/spec/parsing/modifiers/modifier_nodes_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+{ :duplicate => [DuplicateModifierParser.new,DuplicateModifierNode],
+  :transpose => [TransposeModifierParser.new,TransposeModifierNode],
+  :stretch => [StretchModifierParser.new,StretchModifierNode],
+}.each do |modtype,classes|
+  modparser, nodeclass = classes
+
+  describe nodeclass do
+    describe '#process' do
+      it 'should produce a modified array, according to str' do
+        SEQUENCES.each do |seqstr,src|
+          MODIFIERS[modtype].each do |modstr,modlambda|
+            tgt = modlambda.call(src)
+            
+            modnode = modparser.parse(modstr)
+            res = modnode.process src
+            res.should be_a Array
+            res.should eq tgt
+          end
+        end
+      end
+    end
+  end
+end

data/spec/parsing/modifiers/modifier_parsers_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+{ :duplicate => [DuplicateModifierParser,DuplicateModifierNode],
+  :transpose => [TransposeModifierParser,TransposeModifierNode],
+  :stretch => [StretchModifierParser,StretchModifierNode],
+}.each do |modtype,classes|
+  modparser, nodeclass = classes
+  
+  describe modparser do
+    before :all do
+      @parser = modparser.new
+    end
+    
+    it "should parse as #{nodeclass}" do
+      MODIFIERS[modtype].keys.each do |str|
+        @parser.should parse_as(str,nodeclass)
+      end
+    end
+  end
+end

data/spec/parsing/note/accent_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe AccentParser do
+  before :all do
+    @parser = AccentParser.new
+  end
+  
+  it 'should parse a "."' do
+    @parser.parse(".").should_not be nil
+  end
+
+  it "should parse a \"'\"" do
+    @parser.parse("'").should_not be nil
+  end
+  
+  it 'should parse a ">"' do
+    @parser.parse(">").should_not be nil
+  end
+  
+  it 'should parse a "^"' do
+    @parser.parse("^").should_not be nil
+  end
+  
+  it 'should parse a "_"' do
+    @parser.parse("_").should_not be nil
+  end
+end

data/spec/parsing/note/duration_nodes_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe NumDenNode do
+  {
+    '1/2' => Rational(1,2),
+    '5/100' => Rational(5,100),
+    '007/777' => Rational(7,777)
+  }.each do |str,tgt|
+    res = DUR_PARSER.parse(str)
+    context str do
+      it 'should parse as NumDenNode' do
+        res.should be_a NumDenNode
+      end
+
+      describe '#to_r' do
+        r = res.to_r
+        it 'should produce a Rational' do
+          r.should be_a Rational
+        end
+        
+        it 'should produce value matching input str' do
+          r.should eq tgt
+        end
+      end
+    end
+  end
+end
+
+describe NumOnlyNode do
+  {
+    '1/' => Rational(1,1),
+    '5' => Rational(5,1),
+    '007/' => Rational(7,1)
+  }.each do |str,tgt|
+    res = DUR_PARSER.parse(str)
+    context str do
+      it 'should parse as NumOnlyNode' do
+        res.should be_a NumOnlyNode
+      end
+
+      describe '#to_r' do
+        r = res.to_r
+        it 'should produce a Rational' do
+          r.should be_a Rational
+        end
+        
+        it 'should produce value matching input str' do
+          r.should eq tgt
+        end
+      end
+    end
+  end
+end
+
+describe DenOnlyNode do
+  {
+    '/2' => Rational(1,2),
+    '/100' => Rational(1,100),
+    '/777' => Rational(1,777)
+  }.each do |str,tgt|
+    res = DUR_PARSER.parse(str)
+    context str do
+      it 'should parse as DenOnlyNode' do
+        res.should be_a DenOnlyNode
+      end
+
+      describe '#to_r' do
+        r = res.to_r
+        it 'should produce a Rational' do
+          r.should be_a Rational
+        end
+        
+        it 'should produce value matching input str' do
+          r.should eq tgt
+        end
+      end
+    end
+  end
+end

data/spec/parsing/note/duration_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe DurationParser do
+  before :all do
+    @valid = {
+      :numbers => [1,5,50,3999,01,0010,0000005050],
+    }
+    
+    @invalid = {
+      :numbers => [0,00],
+    }    
+  end
+  
+  context 'valid (non-zero) numerator and denominator' do
+    ["n","n/","n/d","/d"].each do |expr|
+      it "should parse durations of the form #{expr}" do
+        @valid[:numbers].each do |n|
+          @valid[:numbers].each do |d|
+            str = expr.gsub('n',"#{n}")
+            str = str.gsub('d',"#{d}")
+            DUR_PARSER.parse(str).should_not be nil
+          end
+        end
+      end
+    end
+  end
+
+  context 'invalid (zero) numerator and valid denominator' do
+    ["n","n/","n/d"].each do |expr|
+      it "should parse durations of the form #{expr}" do
+        @invalid[:numbers].each do |n|
+          @valid[:numbers].each do |d|
+            str = expr.gsub('n',"#{n}")
+            str = str.gsub('d',"#{d}")
+            DUR_PARSER.parse(str).should be nil
+          end
+        end
+      end
+    end
+  end
+    
+  context 'valid numerator and invalid (zero) denominator' do
+    ["n/d","/d"].each do |expr|
+      it "should parse durations of the form #{expr}" do
+        @valid[:numbers].each do |n|
+          @invalid[:numbers].each do |d|
+            str = expr.gsub('n',"#{n}")
+            str = str.gsub('d',"#{d}")
+            DUR_PARSER.parse(str).should be nil
+          end
+        end
+      end
+    end
+  end
+  
+  context 'invalid numerator and invalid denominator' do
+    ["n","n/","n/d","/d"].each do |expr|
+      it "should parse durations of the form #{expr}" do
+        @invalid[:numbers].each do |n|
+          @invalid[:numbers].each do |d|
+            str = expr.gsub('n',"#{n}")
+            str = str.gsub('d',"#{d}")
+            DUR_PARSER.parse(str).should be nil
+          end
+        end
+      end
+    end
+  end  
+end

data/spec/parsing/note/link_node_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe LinkNode do
+  parser = LinkParser.new
+  
+  {
+    '=C4' => Link::Slur.new(C4),
+    '/Db2' => Link::Portamento.new(Db2),
+    '~C#2' => Link::Glissando.new(Db2),
+    '-Db2' => Link::Legato.new(Db2),
+  }.each do |str,tgt|
+    res = parser.parse(str)
+    context str do
+      it 'should parse as LinkNode' do
+        res.should be_a LinkNode
+      end
+      
+      describe '#to_pitch' do
+        l = res.to_link
+        it 'should produce a Link object' do
+          l.should be_a Link
+        end
+        
+        it 'should produce pitch matching input str' do
+          l.should eq tgt
+        end
+      end
+    end
+  end  
+end

data/spec/parsing/note/link_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe LinkParser do
+  before :all do
+    @parser = LinkParser.new
+  end
+  
+  it 'should parse a "=C2"' do
+    @parser.parse("=C2").should_not be nil
+  end
+  
+  it 'should parse a "-C2"' do
+    @parser.parse("-C2").should_not be nil
+  end
+  
+  it 'should parse a "~C2"' do
+    @parser.parse("~C2").should_not be nil
+  end
+  
+  it 'should parse a "/C2"' do
+    @parser.parse("/C2").should_not be nil
+  end
+end