gitara 0.4.0 → 0.4.1

data/spec/lib/gitara/is_node_version_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe IsNodeVersion do
+  class DummyVersion < Valuable
+    include IsNodeVersion
+
+    has_value :node
+  end
+
+  describe "prefix" do
+    it "should be by default the first letter of the class" do
+      dummy_version = DummyVersion.new
+      dummy_version.extend(IsNodeVersion)
+      dummy_version.prefix.should == 'd'
+    end
+  end
+
+  describe "definition_name" do
+    it "should include the node's class and the node's name" do
+      dummy_version = DummyVersion.new(:node => FactoryGirl.build(:base, :name => 'some node'))
+      dummy_version.definition_name.should == 'dBaseSomeNode'
+    end
+  end
+
+  describe "call_name" do
+    it "should be the call version of the definition name" do
+      dummy_version = DummyVersion.new(:node => FactoryGirl.build(:base, :name => 'some node'))
+      dummy_version.call_name.should == '\dBaseSomeNode'
+    end
+  end
+
+  describe "value" do
+    it "should be the call names of its children" do
+      node = FactoryGirl.build(:base, :children => [
+        FactoryGirl.build(:base, :name => :First),
+        FactoryGirl.build(:base, :name => :Second)
+      ])
+      node_version = DummyVersion.new(:node => node)
+      node_version.value.should == '\dBaseFirst \dBaseSecond'
+    end
+  end
+
+  describe "children" do
+    it "should be versionized versions of the node's children" do
+      parent = FactoryGirl.build(:base, :name => 'parent')
+      child = FactoryGirl.build(:base, :name => 'child')
+      parent.add child
+
+      node_version = DummyVersion.new(:node => parent)
+
+      children = node_version.children
+      children.should have(1).child
+      children[0].node.should == child
+      children[0].should be_a(DummyVersion)
+    end
+  end
+end
+

data/spec/lib/gitara/node/bar/chorded_version_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'ChordedVersion' do
+  describe "value" do
+    it "should be the call names of the chord sets in the bar, if available" do
+      bar = FactoryGirl.build(:bar, :children => [FactoryGirl.build(:chord_set, :name => :Am, :value => 'r-"Am"')])
+
+      chorded_bar = FactoryGirl.build(:chorded_bar, :node => bar)
+      chorded_bar.value.should == '\cChordSetAm'
+    end
+
+    it "should be blank, if the bar does not have any chord sets" do
+      bar = FactoryGirl.build(:bar, :children => [FactoryGirl.build(:note_set, :value => 'c')])
+
+      chorded_bar = FactoryGirl.build(:chorded_bar, :node => bar)
+      chorded_bar.value.should == ""
+    end
+  end
+end
+

data/spec/lib/gitara/node/bar/stanza_version_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'StanzaVersion' do
+  describe "value" do
+    it "should be the stanza heading of the bar" do
+      bar = FactoryGirl.build(:bar)
+      stanza = FactoryGirl.build(:stanza, :name => 'Intro', :children => [bar])
+
+      stanza_version_of_bar = FactoryGirl.build(:stanza_version_bar, :node => bar)
+      stanza_version_of_bar.value.should == 'r1^"Intro"'
+    end
+  end
+end
+

data/spec/lib/gitara/node/bar/voiced_version_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Bar::VoicedVersion' do
+  describe "matching_note_set" do
+    it "should be the note_set matching this voiced bar" do
+      note_set = FactoryGirl.build(:note_set)
+
+      bar = FactoryGirl.build(:bar, :children => [note_set])
+
+      voice = FactoryGirl.build(:voice, :id => 1)
+
+      voiced_bar = FactoryGirl.build(:voiced_bar, :node => bar, :voice => voice)
+      voiced_bar.matching_note_set.should == note_set
+    end
+  end
+end

data/spec/lib/gitara/node/bar_spec.rb

@@ -3,20 +3,52 @@ require 'spec_helper'
 describe 'Bar' do
   describe "note_sets" do
     it "should be the note sets of its definition" do
-      definition_bar = Node::Bar.new(:name => 'Intro').tap {|bar|
+      definition_bar = FactoryGirl.build(:bar, :name => 'Intro').tap {|bar|
         bar.children = [
-          Node::NoteSet.new,
-          Node::NoteSet.new
+          FactoryGirl.build(:note_set),
+          FactoryGirl.build(:note_set)
         ]
       }
 
-      call_bar = Node::Bar.new(:name => 'Intro')
+      call_bar = FactoryGirl.build(:bar, :name => 'Intro', :children => [])
 
-      tab = Node::Tab.new.tap {|tab|
-        tab.children = [definition_bar, call_bar]
-      }
+      tab = FactoryGirl.build(:tab, :children => [definition_bar, call_bar])
 
       call_bar.note_sets.should have(2).note_sets
     end
   end
+
+  describe "stanza_heading" do
+    it "should be a whole rest with the stanza name if the bar is the first node of a stanza" do
+      bar = FactoryGirl.build(:bar)
+      stanza = FactoryGirl.build(:stanza, :name => 'Intro', :children => [bar])
+
+      bar.stanza_heading.should == 'r1^"Intro"'
+    end
+
+    it "should be a whole rest with no stanza name if the bar is not the first node of a stanza" do
+      bar = FactoryGirl.build(:bar)
+      bar.stanza_heading.should == 'r1'
+    end
+  end
+
+  describe "first_bar_of_stanza?" do
+    it "should be true if the bar is the first bar of a stanza" do
+      bar = FactoryGirl.build(:bar)
+      stanza = FactoryGirl.build(:stanza, :name => 'Intro', :children => [bar])
+      bar.should be_first_bar_of_stanza
+    end
+
+    it "should be false if the bar is not the first bar of a stanza" do
+      bars = [FactoryGirl.build(:bar), FactoryGirl.build(:bar)]
+      stanza = FactoryGirl.build(:stanza, :name => 'Intro', :children => bars)
+
+      bars[1].should_not be_first_bar_of_stanza
+    end
+
+    it "should be false if the bar does not belong to a stanza" do
+      bar = FactoryGirl.build(:bar)
+      bar.should_not be_first_bar_of_stanza
+    end
+  end
 end

data/spec/lib/gitara/node/base/chorded_version_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe 'ChordedVersion' do
+end
+

data/spec/lib/gitara/node/base/voiced_version_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'VoicedVersion' do
+  describe "prefix" do
+    it "should be based on the voice's id" do
+      voiced_version = FactoryGirl.build(:voiced_version, :node => FactoryGirl.build(:base, :name => 'Intro'), :voice => FactoryGirl.build(:voice, :id => 1))
+      voiced_version.prefix.should == 'vOne'
+    end
+  end
+
+  describe "children" do
+    it "should be voiced versions of the node's children" do
+      parent = FactoryGirl.build(:base, :name => 'parent')
+      child = FactoryGirl.build(:base, :name => 'child')
+      parent.add child
+
+      voice = FactoryGirl.build(:voice, :id => 1)
+
+      voiced_version = FactoryGirl.build(:voiced_version, :node => parent, :voice => voice)
+
+      children = voiced_version.children
+      children.should have(1).voiced_version
+      children[0].node.should == child
+      children[0].voice.should == voice
+    end
+  end
+end
+

data/spec/lib/gitara/node/base_spec.rb

@@ -3,24 +3,22 @@ require 'spec_helper'
 describe Node::Base do
   describe "children" do
     it "should be its own children if they exist" do
-      child = Node::Base.new(:id => nil)
+      child = FactoryGirl.build(:base, :id => nil)
 
-      parent = Node::Base.new
+      parent = FactoryGirl.build(:base)
       parent.children = [child]
       parent.children.should == [child]
     end
 
     it "should be the children of its definition if the node is not a definition" do
-      child = Node::NoteSet.new
-      definition_bar = Node::Bar.new(:name => 'Intro').tap {|bar|
+      child = FactoryGirl.build(:note_set)
+      definition_bar = FactoryGirl.build(:bar, :name => 'Intro').tap {|bar|
         bar.children = [child]
       }
 
-      call_bar = Node::Bar.new(:name => 'Intro')
+      call_bar = FactoryGirl.build(:bar, :name => 'Intro', :children => [])
 
-      tab = Node::Tab.new.tap {|tab|
-        tab.children = [definition_bar, call_bar]
-      }
+      tab = FactoryGirl.build(:tab, :children => [definition_bar, call_bar])
 
       call_bar.children.should == [child]
     end
@@ -28,8 +26,8 @@ describe Node::Base do
 
   describe "children=(other)" do
     it "should set the ids and parents of the children" do
-      parent = Node::Base.new
-      parent.children = [Node::Base.new(:id => nil)]
+      parent = FactoryGirl.build(:base)
+      parent.children = [FactoryGirl.build(:base, :id => nil)]
       parent.children[0].id.should == 1
       parent.children[0].parent.should == parent
     end
@@ -37,29 +35,29 @@ describe Node::Base do
 
   describe "add(child)" do
     it "should set the id and parent of the child" do
-      parent = Node::Base.new
+      parent = FactoryGirl.build(:base)
 
-      parent.add Node::Base.new(:id => nil)
+      parent.add FactoryGirl.build(:base, :id => nil)
       parent.children[0].id.should == 1
       parent.children[0].parent.should == parent
 
-      parent.add Node::Base.new(:id => nil)
+      parent.add FactoryGirl.build(:base, :id => nil)
       parent.children[1].id.should == 2
       parent.children[1].parent.should == parent
     end
 
     it "should set the id based on existing siblings having the same class as the child" do
-      parent = Node::Base.new
+      parent = FactoryGirl.build(:base)
 
-      bar_1 = Node::Bar.new
+      bar_1 = FactoryGirl.build(:bar)
       parent.add bar_1
       bar_1.id.should == 1
 
-      line_1 = Node::Line.new
+      line_1 = FactoryGirl.build(:line)
       parent.add line_1
       line_1.id.should == 1
 
-      bar_2 = Node::Bar.new
+      bar_2 = FactoryGirl.build(:bar)
       parent.add bar_2
       bar_2.id.should == 2
     end
@@ -67,18 +65,16 @@ describe Node::Base do
 
   describe "definition" do
     it "should be the definition node which matches this node's name" do
-      definition_bar = Node::Bar.new(:name => 'Intro').tap {|bar|
+      definition_bar = FactoryGirl.build(:bar, :name => 'Intro').tap {|bar|
         bar.children = [
-          Node::NoteSet.new,
-          Node::NoteSet.new
+          FactoryGirl.build(:note_set),
+          FactoryGirl.build(:note_set)
         ]
       }
 
-      call_bar = Node::Bar.new(:name => 'Intro')
+      call_bar = FactoryGirl.build(:bar, :name => 'Intro', :children => [])
 
-      tab = Node::Tab.new.tap {|tab|
-        tab.children = [definition_bar, call_bar]
-      }
+      tab = FactoryGirl.build(:tab, :children => [definition_bar, call_bar])
 
       call_bar.send(:definition).should == definition_bar
     end
@@ -86,21 +82,21 @@ describe Node::Base do
 
   describe "definition?" do
     it "should be true if this node has children" do
-      definition_bar = Node::Bar.new(:name => 'Intro').tap {|bar|
-        bar.add Node::NoteSet.new
-        bar.add Node::NoteSet.new
+      definition_bar = FactoryGirl.build(:bar, :name => 'Intro').tap {|bar|
+        bar.add FactoryGirl.build(:note_set)
+        bar.add FactoryGirl.build(:note_set)
       }
       definition_bar.should be_definition
     end
 
     it "should be true if the node has a value" do
-      chord_set = Node::ChordSet.new(:name => :Am, :value =>'r4-"Am" r r r')
+      chord_set = FactoryGirl.build(:chord_set, :name => :Am, :value =>'r4-"Am" r r r')
       chord_set.own_children.should be_empty
       chord_set.should be_definition
     end
 
     it "should be false if this node does not have children and it does not have a value" do
-      call_bar = Node::Bar.new(:name => 'Intro')
+      call_bar = FactoryGirl.build(:bar, :name => 'Intro', :children => [])
       call_bar.own_children.should be_empty
       call_bar.value.should be_nil
       call_bar.should_not be_definition
@@ -109,31 +105,31 @@ describe Node::Base do
 
   describe "value" do
     it "should convert slashes to backslashes" do
-      node = Node::Base.new(:value => %q|notes "<g'/1>8 <a/3>8 <g'/1>8 <a/3>16 <g'/1>8 <g/3>16 <e'/1>4 <g/3>8"|)
+      node = FactoryGirl.build(:base, :value => %q|notes "<g'/1>8 <a/3>8 <g'/1>8 <a/3>16 <g'/1>8 <g/3>16 <e'/1>4 <g/3>8"|)
       node.value.should == %q|notes "<g'\1>8 <a\3>8 <g'\1>8 <a\3>16 <g'\1>8 <g\3>16 <e'\1>4 <g\3>8"|
     end
   end
 
   describe "voiced_as(arg)" do
     it "should return the voiced version of the node, if arg is a voice" do
-      node = Node::Base.new
-      voice = Voice.new
+      node = FactoryGirl.build(:base)
+      voice = FactoryGirl.build(:voice)
 
       node_voice_pair = node.voiced_as(voice)
-      node_voice_pair.should be_a(Node::Base::VoicedNode)
+      node_voice_pair.should be_a(Node::Base::VoicedVersion)
       node_voice_pair.node.should == node
       node_voice_pair.voice.should == voice
     end
 
     it "should return the voiced versions of the node, if arg are voices" do
-      node = Node::Base.new
-      voices = [Voice.new, Voice.new]
+      node = FactoryGirl.build(:base)
+      voices = [FactoryGirl.build(:voice), FactoryGirl.build(:voice)]
 
       node_voice_pairs = node.voiced_as(voices)
       node_voice_pairs.size.should == 2
 
       node_voice_pairs.each do |pair|
-        pair.should be_a(Node::Base::VoicedNode)
+        pair.should be_a(Node::Base::VoicedVersion)
         pair.node.should == node
       end
 
@@ -144,27 +140,18 @@ describe Node::Base do
 
   describe "definitions(klass)" do
     it "should be itself if it is an instance of the klass" do
-      node = Node::Bar.new
-      node.add Node::NoteSet.new
+      node = FactoryGirl.build(:bar)
+      node.add FactoryGirl.build(:note_set)
       node.should be_definition
 
       node.definitions(Node::Bar).should == [node]
     end
 
     it "should include descendants which are instances of klass" do
-      node = Node::Base.new.tap do |base|
-        base.add(
-          Node::Bar.new.tap do |bar|
-            bar.add Node::NoteSet.new
-          end
-        )
-
-        base.add(
-          Node::Bar.new.tap do |bar|
-            bar.add Node::NoteSet.new
-          end
-        )
-      end
+      node = FactoryGirl.build(:base, :children => [
+        FactoryGirl.build(:bar, :children => [FactoryGirl.build(:note_set)]),
+        FactoryGirl.build(:bar, :children => [FactoryGirl.build(:note_set)])
+      ])
 
       node.definitions(Node::Bar).should have(2).bars
     end
@@ -172,17 +159,17 @@ describe Node::Base do
 
   describe "root" do
     it "should be itself if it has no parent" do
-      node = Node::Base.new
+      node = FactoryGirl.build(:base)
       node.root.should == node
     end
 
     it "should be the ancentor of the node which has no parent of its own" do
-      note_set = Node::NoteSet.new
+      note_set = FactoryGirl.build(:note_set)
 
-      bar = Node::Bar.new
+      bar = FactoryGirl.build(:bar)
       bar.add note_set
 
-      root = Node::Base.new
+      root = FactoryGirl.build(:base)
       root.add bar
 
       note_set.root.should == root
@@ -191,55 +178,53 @@ describe Node::Base do
 
   describe "name" do
     it "should be the given name, if available" do
-      Node::Bar.new(:name => :Intro).name.should == :Intro
+      FactoryGirl.build(:bar, :name => :Intro).name.should == :Intro
     end
 
     it "should be based on the parent's name the node's class and id, if not available" do
-      child = Node::NoteSet.new
-      bar = Node::Bar.new(:name => :Intro).tap do |bar|
-        bar.add child
-      end
+      child = FactoryGirl.build(:note_set)
+      bar = FactoryGirl.build(:bar, :name => :Intro, :children => [child])
 
       child.name.should == "IntroNoteSetOne"
     end
 
     it "should be based on the node's class and id, if there's no parent and the there's no given name" do
-      child = Node::NoteSet.new
+      child = FactoryGirl.build(:note_set)
       child.name.should == "NoteSetOne"
     end
   end
 
   describe "id" do
     it "should be 1 by default" do
-      child = Node::NoteSet.new
+      child = FactoryGirl.build(:note_set)
       child.id.should == 1
     end
   end
 
   describe "id_as_word" do
     it "should camelize if necessary" do
-      node = Node::Base.new(:id => 24)
+      node = FactoryGirl.build(:base, :id => 24)
       node.id_as_word.should == "TwentyFour"
     end
   end
 
   describe "definition_name" do
     it "should turn the name to a lilypond acceptable name" do
-      node = Node::Base.new(:name => "Verse 1 line-2")
+      node = FactoryGirl.build(:base, :name => "Verse 1 line-2")
       node.definition_name.should == "VerseOneLineTwo"
     end
   end
 
   describe "descendants(klass)" do
     it "should be itself if it is an instance of the klass" do
-      tab = Node::Tab.new(:children => [Node::Bar.new])
+      tab = FactoryGirl.build(:tab, :children => [FactoryGirl.build(:bar)])
       tab.descendants(Node::Tab).should == [tab]
     end
 
     it "should include descendants which are instances of klass" do
-      tab = Node::Tab.new(:children => [
-        Node::Bar.new(:name => :Intro, :children => [
-          Node::NoteSet.new
+      tab = FactoryGirl.build(:tab, :children => [
+        FactoryGirl.build(:bar, :name => :Intro, :children => [
+          FactoryGirl.build(:note_set)
         ])
       ])
 
@@ -247,17 +232,15 @@ describe Node::Base do
     end
 
     it "should follow the definitions of node references for descendants" do
-      tab = Node::Tab.new(:children => [
-        Node::Bar.new(:name => :Intro, :children => [
-          Node::NoteSet.new
-        ]),
+      tab = FactoryGirl.build(:tab, :children => [
+        FactoryGirl.build(:bar, :name => :Intro, :children => [FactoryGirl.build(:note_set)]),
 
-        Node::Line.new(:name => 'Line 1', :children => [
-          Node::Bar.new(:name => :Intro)
+        FactoryGirl.build(:line, :name => 'Line 1', :children => [
+          FactoryGirl.build(:bar, :name => :Intro , :children => [])
         ]),
 
-        Node::Stanza.new(:children => [
-          Node::Line.new(:name => 'Line 1')
+        FactoryGirl.build(:stanza, :children => [
+          FactoryGirl.build(:line, :name => 'Line 1', :children => [])
         ])
       ])
 
@@ -270,9 +253,34 @@ describe Node::Base do
 
   describe "chorded" do
     it "should return the chorded version of the node" do
-      node = Node::ChordSet.new
-      chorded_node = node.chorded
-      chorded_node.node.should == node
+      node = FactoryGirl.build(:base)
+      chorded_version = node.chorded
+      chorded_version.node.should == node
+      chorded_version.should be_a(Node::Base::ChordedVersion)
+    end
+  end
+
+  describe "stanza_version" do
+    it "should be a stanza version of the node" do
+      node = FactoryGirl.build(:base)
+      stanza_version = node.stanza_version
+      stanza_version.node.should == node
+      stanza_version.should be_a(Node::Base::StanzaVersion)
+    end
+  end
+
+  describe "ancestor(node_class)" do
+    it "should be the first ancestor of the node matching the node class" do
+      bar = FactoryGirl.build(:bar)
+      line = FactoryGirl.build(:line, :name => 'Intro', :children => [bar])
+      stanza = FactoryGirl.build(:stanza, :name => 'Intro', :children => [line])
+
+      bar.ancestor(Node::Stanza).should == stanza
+    end
+
+    it "should be nil if there is no ancestor matching the node class" do
+      bar = FactoryGirl.build(:bar)
+      bar.ancestor(Node::Stanza).should be_nil
     end
   end
 end