gitara 1.0.0 → 1.2.0

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

@@ -4,62 +4,62 @@ describe Gitara::Node::Base::NodeVersion do
   describe "#prefix" do
     it "should be by default the first letter of the class" do
       version = Node::Base::NodeVersion.new
-      version.prefix.should == 'n'
+      expect(version.prefix).to eq('n')
     end
   end
 
   describe "#definition_name" do
     it "should include the node's class and the node's name" do
-      version = Node::Base::NodeVersion.new(:node => FactoryGirl.build(:base, :name => 'some node'))
-      version.definition_name.should == 'nBaseSomeNode'
+      version = Node::Base::NodeVersion.new(:node => FactoryBot.build(:base, :name => 'some node'))
+      expect(version.definition_name).to eq('nBaseSomeNode')
     end
   end
 
   describe "#call_name" do
     it "should be the call version of the definition name" do
-      version = Node::Base::NodeVersion.new(:node => FactoryGirl.build(:base, :name => 'some node'))
-      version.call_name.should == '\nBaseSomeNode'
+      version = Node::Base::NodeVersion.new(:node => FactoryBot.build(:base, :name => 'some node'))
+      expect(version.call_name).to eq('\nBaseSomeNode')
     end
   end
 
   describe "#value" do
     it "should be the call values of its definition_children" do
-      node = FactoryGirl.build(:base, :children => [
-        FactoryGirl.build(:base, :name => :First),
-        FactoryGirl.build(:base, :name => :Second)
+      node = FactoryBot.build(:base, :children => [
+        FactoryBot.build(:base, :name => :First),
+        FactoryBot.build(:base, :name => :Second)
       ])
       node_version = Node::Base::NodeVersion.new(:node => node)
-      node_version.value.should == '\nBaseFirst \nBaseSecond'
+      expect(node_version.value).to eq('\nBaseFirst \nBaseSecond')
     end
   end
 
   describe "#definition_children" do
     it "should be versionized versions of the node's definition_children" do
-      parent = FactoryGirl.build(:base, :name => 'parent')
-      child = FactoryGirl.build(:base, :name => 'child')
+      parent = FactoryBot.build(:base, :name => 'parent')
+      child = FactoryBot.build(:base, :name => 'child')
       parent.add child
 
       node_version = Node::Base::NodeVersion.new(:node => parent)
 
       children = node_version.definition_children
-      children.should have(1).child
-      children[0].node.should == child
-      children[0].should be_a(Node::Base::NodeVersion)
+      expect(children.size).to eq(1)
+      expect(children[0].node).to eq(child)
+      expect(children[0]).to be_a(Node::Base::NodeVersion)
     end
   end
 
   describe "#call_value" do
     it "should be the call name if we want to render the node's definition name in the lilypond output" do
-      node = FactoryGirl.build(:base, :name => 'parent')
+      node = FactoryBot.build(:base, :name => 'parent')
       node_version = Node::Base::NodeVersion.new(:node => node)
-      node_version.call_value.should == '\nBaseParent'
+      expect(node_version.call_value).to eq('\nBaseParent')
     end
 
     it "should be the call value of the node if we don't want to render the node's definition name in the lilypond output" do
-      node = FactoryGirl.build(:base, :name => 'name')
+      node = FactoryBot.build(:base, :name => 'name')
       node_version = Node::Base::NodeVersion.new(:node => node)
-      node.should_receive(:call_value).with(node_version).and_return("todo { }")
-      node_version.call_value.should == "todo { }"
+      expect(node).to receive(:call_value).with(node_version).and_return("todo { }")
+      expect(node_version.call_value).to eq("todo { }")
     end
   end
 end

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

@@ -3,25 +3,25 @@ require 'spec_helper'
 describe Gitara::Node::Base::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'
+      voiced_version = FactoryBot.build(:voiced_version, :node => FactoryBot.build(:base, :name => 'Intro'), :voice => FactoryBot.build(:voice, :id => 1))
+      expect(voiced_version.prefix).to eq('vOne')
     end
   end
 
   describe "#definition_children" do
     it "should be voiced versions of the node's definition_children" do
-      parent = FactoryGirl.build(:base, :name => 'parent')
-      child = FactoryGirl.build(:base, :name => 'child')
+      parent = FactoryBot.build(:base, :name => 'parent')
+      child = FactoryBot.build(:base, :name => 'child')
       parent.add child
 
-      voice = FactoryGirl.build(:voice, :id => 1)
+      voice = FactoryBot.build(:voice, :id => 1)
 
-      voiced_version = FactoryGirl.build(:voiced_version, :node => parent, :voice => voice)
+      voiced_version = FactoryBot.build(:voiced_version, :node => parent, :voice => voice)
 
       children = voiced_version.definition_children
-      children.should have(1).voiced_version
-      children[0].node.should == child
-      children[0].voice.should == voice
+      expect(children.size).to eq(1)
+      expect(children[0].node).to eq(child)
+      expect(children[0].voice).to eq(voice)
     end
   end
 end

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

@@ -3,278 +3,285 @@ require 'spec_helper'
 describe Gitara::Node::Base do
   describe "#definition_children" do
     it "should be its own children if they exist" do
-      child = FactoryGirl.build(:base, :id => nil)
+      child = FactoryBot.build(:base, :id => nil)
 
-      parent = FactoryGirl.build(:base)
+      parent = FactoryBot.build(:base)
       parent.children = [child]
-      parent.definition_children.should == [child]
+      expect(parent.definition_children).to eq([child])
     end
 
     it "should be the children of its definition if the node is not a definition" do
-      child = FactoryGirl.build(:note_set)
-      definition_bar = FactoryGirl.build(:bar, :name => 'Intro').tap {|bar|
+      child = FactoryBot.build(:note_set)
+      definition_bar = FactoryBot.build(:bar, :name => 'Intro').tap {|bar|
         bar.children = [child]
       }
 
-      call_bar = FactoryGirl.build(:bar, :name => 'Intro', :children => [])
+      call_bar = FactoryBot.build(:bar, :name => 'Intro', :children => [])
 
-      tab = FactoryGirl.build(:tab, :children => [definition_bar, call_bar])
+      tab = FactoryBot.build(:tab, :children => [definition_bar, call_bar])
 
-      call_bar.definition_children.should == [child]
+      expect(call_bar.definition_children).to eq([child])
     end
   end
 
   describe "#children=" do
     it "should set the ids and parents of the children" do
-      parent = FactoryGirl.build(:base)
-      parent.children = [FactoryGirl.build(:base, :id => nil)]
-      parent.children[0].id.should == 1
-      parent.children[0].parent.should == parent
+      parent = FactoryBot.build(:base)
+      parent.children = [FactoryBot.build(:base, :id => nil)]
+      expect(parent.children[0].id).to eq(1)
+      expect(parent.children[0].parent).to eq(parent)
     end
   end
 
   describe "#add" do
     it "should set the id and parent of the child" do
-      parent = FactoryGirl.build(:base)
+      parent = FactoryBot.build(:base)
 
-      parent.add FactoryGirl.build(:base, :id => nil)
-      parent.children[0].id.should == 1
-      parent.children[0].parent.should == parent
+      parent.add FactoryBot.build(:base, :id => nil)
+      expect(parent.children[0].id).to eq(1)
+      expect(parent.children[0].parent).to eq(parent)
 
-      parent.add FactoryGirl.build(:base, :id => nil)
-      parent.children[1].id.should == 2
-      parent.children[1].parent.should == parent
+      parent.add FactoryBot.build(:base, :id => nil)
+      expect(parent.children[1].id).to eq(2)
+      expect(parent.children[1].parent).to eq(parent)
     end
 
     it "should set the id based on existing siblings having the same class as the child" do
-      parent = FactoryGirl.build(:base)
+      parent = FactoryBot.build(:base)
 
-      bar_1 = FactoryGirl.build(:bar)
+      bar_1 = FactoryBot.build(:bar)
       parent.add bar_1
-      bar_1.id.should == 1
+      expect(bar_1.id).to eq(1)
 
-      line_1 = FactoryGirl.build(:line)
+      line_1 = FactoryBot.build(:line)
       parent.add line_1
-      line_1.id.should == 1
+      expect(line_1.id).to eq(1)
 
-      bar_2 = FactoryGirl.build(:bar)
+      bar_2 = FactoryBot.build(:bar)
       parent.add bar_2
-      bar_2.id.should == 2
+      expect(bar_2.id).to eq(2)
     end
   end
 
   describe "#definition" do
     it "should be the definition node which matches this node's name" do
-      definition_bar = FactoryGirl.build(:bar, :name => 'Intro').tap {|bar|
+      definition_bar = FactoryBot.build(:bar, :name => 'Intro').tap {|bar|
         bar.children = [
-          FactoryGirl.build(:note_set),
-          FactoryGirl.build(:note_set)
+          FactoryBot.build(:note_set),
+          FactoryBot.build(:note_set)
         ]
       }
 
-      call_bar = FactoryGirl.build(:bar, :name => 'Intro', :children => [])
+      call_bar = FactoryBot.build(:bar, :name => 'Intro', :children => [])
 
-      tab = FactoryGirl.build(:tab, :children => [definition_bar, call_bar])
+      tab = FactoryBot.build(:tab, :children => [definition_bar, call_bar])
 
-      call_bar.send(:definition).should == definition_bar
+      expect(call_bar.send(:definition)).to eq(definition_bar)
     end
   end
 
   describe "#definition?" do
     it "should be true if this node has children" do
-      definition_bar = FactoryGirl.build(:bar, :name => 'Intro').tap {|bar|
-        bar.add FactoryGirl.build(:note_set)
-        bar.add FactoryGirl.build(:note_set)
+      definition_bar = FactoryBot.build(:bar, :name => 'Intro').tap {|bar|
+        bar.add FactoryBot.build(:note_set)
+        bar.add FactoryBot.build(:note_set)
       }
-      definition_bar.should be_definition
+      expect(definition_bar).to be_definition
     end
 
     it "should be true if the node has a value" do
-      chord_set = FactoryGirl.build(:chord_set, :name => :Am, :value =>'r4-"Am" r r r')
-      chord_set.children.should be_empty
-      chord_set.should be_definition
+      chord_set = FactoryBot.build(:chord_set, :name => :Am, :value =>'r4-"Am" r r r')
+      expect(chord_set.children).to be_empty
+      expect(chord_set).to be_definition
     end
 
     it "should be false if this node does not have children and it does not have a value" do
-      call_bar = FactoryGirl.build(:bar, :name => 'Intro', :children => [])
-      call_bar.children.should be_empty
-      call_bar.value.should be_nil
-      call_bar.should_not be_definition
+      call_bar = FactoryBot.build(:bar, :name => 'Intro', :children => [])
+      expect(call_bar.children).to be_empty
+      expect(call_bar.value).to be_nil
+      expect(call_bar).to_not be_definition
     end
   end
 
   describe "#value" do
     it "should convert slashes to backslashes" do
-      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"|
+      node = FactoryBot.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"|)
+      expect(node.value).to eq(%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
 
     it "should work with non-strings" do
-      node = FactoryGirl.build(:base, :value => 1)
-      node.value.should == 1
+      node = FactoryBot.build(:base, :value => 1)
+      expect(node.value).to eq(1)
     end
   end
 
   describe "#voiced_as" do
     it "should return the voiced version of the node, if arg is a voice" do
-      node = FactoryGirl.build(:base)
-      voice = FactoryGirl.build(:voice)
+      node = FactoryBot.build(:base)
+      voice = FactoryBot.build(:voice)
 
       node_voice_pair = node.voiced_as(voice)
-      node_voice_pair.should be_a(Node::Base::VoicedVersion)
-      node_voice_pair.node.should == node
-      node_voice_pair.voice.should == voice
+      expect(node_voice_pair).to be_a(Node::Base::VoicedVersion)
+      expect(node_voice_pair.node).to eq(node)
+      expect(node_voice_pair.voice).to eq(voice)
     end
 
     it "should return the voiced versions of the node, if arg are voices" do
-      node = FactoryGirl.build(:base)
-      voices = [FactoryGirl.build(:voice), FactoryGirl.build(:voice)]
+      node = FactoryBot.build(:base)
+      voices = [FactoryBot.build(:voice), FactoryBot.build(:voice)]
 
       node_voice_pairs = node.voiced_as(voices)
-      node_voice_pairs.size.should == 2
+      expect(node_voice_pairs.size).to eq(2)
 
       node_voice_pairs.each do |pair|
-        pair.should be_a(Node::Base::VoicedVersion)
-        pair.node.should == node
+        expect(pair).to be_a(Node::Base::VoicedVersion)
+        expect(pair.node).to eq(node)
       end
 
-      node_voice_pairs[0].voice.should == voices[0]
-      node_voice_pairs[1].voice.should == voices[1]
+      expect(node_voice_pairs[0].voice).to eq(voices[0])
+      expect(node_voice_pairs[1].voice).to eq(voices[1])
     end
   end
 
   describe "#definitions" do
     it "should be itself if it is an instance of the klass" do
-      node = FactoryGirl.build(:bar)
-      node.add FactoryGirl.build(:note_set)
-      node.should be_definition
+      node = FactoryBot.build(:bar)
+      node.add FactoryBot.build(:note_set)
+      expect(node).to be_definition
 
-      node.definitions(Node::Bar).should == [node]
+      expect(node.definitions(Node::Bar)).to eq([node])
     end
 
     it "should include descendants which are instances of klass" do
-      node = FactoryGirl.build(:base, :children => [
-        FactoryGirl.build(:bar, :children => [FactoryGirl.build(:note_set)]),
-        FactoryGirl.build(:bar, :children => [FactoryGirl.build(:note_set)])
+      node = FactoryBot.build(:base, :children => [
+        FactoryBot.build(:bar, :children => [FactoryBot.build(:note_set)]),
+        FactoryBot.build(:bar, :children => [FactoryBot.build(:note_set)])
       ])
 
-      node.definitions(Node::Bar).should have(2).bars
+      expect(node.definitions(Node::Bar).size).to eq(2)
     end
   end
 
   describe "#name" do
     it "should be the given name, if available" do
-      FactoryGirl.build(:bar, :name => :Intro).name.should == :Intro
+      expect(FactoryBot.build(:bar, :name => :Intro).name).to eq(:Intro)
     end
 
     it "should be based on the parent's name the node's class and id, if not available" do
-      child = FactoryGirl.build(:note_set)
-      bar = FactoryGirl.build(:bar, :name => :Intro, :children => [child])
+      child = FactoryBot.build(:note_set)
+      bar = FactoryBot.build(:bar, :name => :Intro, :children => [child])
 
-      child.name.should == "IntroNoteSetOne"
+      expect(child.name).to eq("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 = FactoryGirl.build(:note_set)
-      child.name.should == "NoteSetOne"
+      child = FactoryBot.build(:note_set)
+      expect(child.name).to eq("NoteSetOne")
     end
   end
 
   describe "#id" do
     it "should be 1 by default" do
-      child = FactoryGirl.build(:note_set)
-      child.id.should == 1
+      child = FactoryBot.build(:note_set)
+      expect(child.id).to eq(1)
     end
   end
 
   describe "#id_as_word" do
     it "should camelize if necessary" do
-      node = FactoryGirl.build(:base, :id => 24)
-      node.id_as_word.should == "TwentyFour"
+      node = FactoryBot.build(:base, :id => 24)
+      expect(node.id_as_word).to eq("TwentyFour")
     end
   end
 
   describe "#definition_name" do
     it "should turn the name to a lilypond acceptable name" do
-      node = FactoryGirl.build(:base, :name => "Verse 1 line-2")
-      node.definition_name.should == "VerseOneLineTwo"
+      node = FactoryBot.build(:base, :name => "Verse 1 line-2")
+      expect(node.definition_name).to eq("VerseOneLineTwo")
+    end
+
+    context 'when a word of the name is already camelized' do
+      it 'should retain the camelization' do
+        node = FactoryBot.build(:base, :name => "Verse 1LineOne")
+        expect(node.definition_name).to eq("VerseOneLineOne")
+      end
     end
   end
 
   describe "#descendants" do
     it "should be itself if it is an instance of the klass" do
-      tab = FactoryGirl.build(:tab, :children => [FactoryGirl.build(:bar)])
-      tab.descendants(Node::Tab).should == [tab]
+      tab = FactoryBot.build(:tab, :children => [FactoryBot.build(:bar)])
+      expect(tab.descendants(Node::Tab)).to eq([tab])
     end
 
     it "should include descendants which are instances of klass" do
-      tab = FactoryGirl.build(:tab, :children => [
-        FactoryGirl.build(:bar, :name => :Intro, :children => [
-          FactoryGirl.build(:note_set)
+      tab = FactoryBot.build(:tab, :children => [
+        FactoryBot.build(:bar, :name => :Intro, :children => [
+          FactoryBot.build(:note_set)
         ])
       ])
 
-      tab.descendants(Node::Bar).should have(1).bar
+      expect(tab.descendants(Node::Bar).size).to eq(1)
     end
 
     it "should follow the definitions of node references for descendants" do
-      tab = FactoryGirl.build(:tab, :children => [
-        FactoryGirl.build(:bar, :name => :Intro, :children => [FactoryGirl.build(:note_set)]),
+      tab = FactoryBot.build(:tab, :children => [
+        FactoryBot.build(:bar, :name => :Intro, :children => [FactoryBot.build(:note_set)]),
 
-        FactoryGirl.build(:line, :name => 'Line 1', :children => [
-          FactoryGirl.build(:bar, :name => :Intro , :children => [])
+        FactoryBot.build(:line, :name => 'Line 1', :children => [
+          FactoryBot.build(:bar, :name => :Intro , :children => [])
         ]),
 
-        FactoryGirl.build(:stanza, :children => [
-          FactoryGirl.build(:line, :name => 'Line 1', :children => [])
+        FactoryBot.build(:stanza, :children => [
+          FactoryBot.build(:line, :name => 'Line 1', :children => [])
         ])
       ])
 
       bar = tab.children[0]
 
       stanza = tab.children[2]
-      stanza.descendants(Node::Bar).should == [bar]
+      expect(stanza.descendants(Node::Bar)).to eq([bar])
     end
   end
 
   describe "#chorded" do
     it "should return the chorded version of the node" do
-      node = FactoryGirl.build(:base)
+      node = FactoryBot.build(:base)
       chorded_version = node.chorded
-      chorded_version.node.should == node
-      chorded_version.should be_a(Node::Base::ChordedVersion)
+      expect(chorded_version.node).to eq(node)
+      expect(chorded_version).to 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)
+      node = FactoryBot.build(:base)
       stanza_version = node.stanza_version
-      stanza_version.node.should == node
-      stanza_version.should be_a(Node::Base::StanzaVersion)
+      expect(stanza_version.node).to eq(node)
+      expect(stanza_version).to be_a(Node::Base::StanzaVersion)
     end
   end
 
   describe "#ancestor" 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 = FactoryBot.build(:bar)
+      line = FactoryBot.build(:line, :name => 'Intro', :children => [bar])
+      stanza = FactoryBot.build(:stanza, :name => 'Intro', :children => [line])
 
-      bar.ancestor(Node::Stanza).should == stanza
+      expect(bar.ancestor(Node::Stanza)).to eq(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
+      bar = FactoryBot.build(:bar)
+      expect(bar.ancestor(Node::Stanza)).to be_nil
     end
   end
 
   describe "#call_value" do
     it "should be the call name by default" do
-      node = FactoryGirl.build(:base, :name => 'MyNode')
+      node = FactoryBot.build(:base, :name => 'MyNode')
       node_version = Node::Base::NodeVersion.new(:node => node)
-      node.call_value(node_version).should == '\nBaseMyNode'
+      expect(node.call_value(node_version)).to eq('\nBaseMyNode')
     end
   end
 end

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

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe Gitara::Node::ChordSet::ChordedVersion do
   describe "#value" do
     it "should be the chord set's value" do
-      chorded_version = FactoryGirl.build(:chorded_chord_set, :node => FactoryGirl.build(:chord_set, :name => :Am, :value => '4r-"Am" r r r'))
-      chorded_version.value.should == '4r-"Am" r r r'
+      chorded_version = FactoryBot.build(:chorded_chord_set, :node => FactoryBot.build(:chord_set, :name => :Am, :value => '4r-"Am" r r r'))
+      expect(chorded_version.value).to eq('4r-"Am" r r r')
     end
   end
 end

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

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Gitara::Node::Line do
   describe "#manual_break?" do
     it "should be true by default" do
-      described_class.new.manual_break?.should be_true
+      expect(described_class.new.manual_break?).to be_truthy
     end
     
     it "should be based on #manual_break field" do
       line = described_class.new
       line.manual_break = false
-      line.manual_break?.should be_false
+      expect(line.manual_break?).to be_falsy
     end
   end
 end

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

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe Gitara::Node::Repeat do
   describe "#call_value" do
     it "should be a call to lilypond's repeat command" do
-      repeat = FactoryGirl.build(:repeat, :value => 2, :children => [
-        FactoryGirl.build(:bar)
+      repeat = FactoryBot.build(:repeat, :value => 2, :children => [
+        FactoryBot.build(:bar)
       ])
 
       version = Node::Base::NodeVersion.new(:node => repeat)
-      repeat.call_value(version).should == "\\repeat volta 2 { \\nBarRepeatOneBarOne }"
+      expect(repeat.call_value(version)).to eq("\\repeat volta 2 { \\nBarRepeatOneBarOne }")
     end
   end
 

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

@@ -3,34 +3,34 @@ require 'spec_helper'
 describe Gitara::Node::Stanza do
   describe "#heading_in_lilypond" do
     it "should allow the stanza's name to be added as a heading to the lilypond template" do
-      stanza = FactoryGirl.build(:stanza, :name => "Verse 1", :children => [
-        FactoryGirl.build(:line, :children => [
-          FactoryGirl.build(:bar),
-          FactoryGirl.build(:bar),
+      stanza = FactoryBot.build(:stanza, :name => "Verse 1", :children => [
+        FactoryBot.build(:line, :children => [
+          FactoryBot.build(:bar),
+          FactoryBot.build(:bar),
         ])
       ])
 
-      tab = FactoryGirl.build(:tab, :time => '4/4', :children => [stanza])
+      tab = FactoryBot.build(:tab, :time => '4/4', :children => [stanza])
 
-      stanza.heading_in_lilypond.should == 'r1^"Verse 1" r1'
+      expect(stanza.heading_in_lilypond).to eq('r1^"Verse 1" r1')
     end
   end
 
   describe "#heading_for_first_bar" do
     it "should be the time signature's rest bar value with the stanza name if the time signature will generate whole note bars" do
-      bar = FactoryGirl.build(:bar)
-      stanza = FactoryGirl.build(:stanza, :name => 'Intro', :children => [bar])
-      tab = FactoryGirl.build(:tab, :children => [stanza], :time => '4/4')
+      bar = FactoryBot.build(:bar)
+      stanza = FactoryBot.build(:stanza, :name => 'Intro', :children => [bar])
+      tab = FactoryBot.build(:tab, :children => [stanza], :time => '4/4')
 
-      stanza.heading_for_first_bar.should == 'r1^"Intro"'
+      expect(stanza.heading_for_first_bar).to eq('r1^"Intro"')
     end
 
     it "should attach the stanza name to the first rest note if the time signature will not generate whole note bars" do
-      bar = FactoryGirl.build(:bar)
-      stanza = FactoryGirl.build(:stanza, :name => 'Intro', :children => [bar])
-      tab = FactoryGirl.build(:tab, :children => [stanza], :time => '3/4')
+      bar = FactoryBot.build(:bar)
+      stanza = FactoryBot.build(:stanza, :name => 'Intro', :children => [bar])
+      tab = FactoryBot.build(:tab, :children => [stanza], :time => '3/4')
 
-      stanza.heading_for_first_bar.should == 'r4^"Intro" r4 r4'
+      expect(stanza.heading_for_first_bar).to eq('r4^"Intro" r4 r4')
     end
   end
 end