gitara 1.0.0 → 1.2.0

data/spec/lib/gitara/dsl_spec.rb

@@ -3,324 +3,324 @@ require 'spec_helper'
 describe Gitara::Dsl do
   describe "#bar" do
     it "should add a bar with the name" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
       dsl.bar 'Intro'
 
-      dsl.node.children.should have(1).bar
+      expect(dsl.node.children.size).to eq(1)
 
       bar = dsl.node.children[0]
-      bar.name.should == 'Intro'
-      bar.children.should be_empty
+      expect(bar.name).to eq('Intro')
+      expect(bar.children).to be_empty
     end
 
     it "should add the definition_children declared in the block to the bar" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
-      note_set = FactoryGirl.build(:note_set)
+      note_set = FactoryBot.build(:note_set)
 
       dsl.bar 'Intro' do
         add note_set
       end
 
-      dsl.node.children.should have(1).bar
-      dsl.node.children[0].name.should == 'Intro'
+      expect(dsl.node.children.size).to eq(1)
+      expect(dsl.node.children[0].name).to eq('Intro')
 
       bar = dsl.node.children[0]
-      bar.children.should have(1).note_set
-      bar.children[0].should == note_set
+      expect(bar.children.size).to eq(1)
+      expect(bar.children[0]).to eq(note_set)
     end
   end
 
   describe "#add" do
     it "should add the child to the dsl's node" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
-      bar = FactoryGirl.build(:bar, :name => 'Intro')
+      bar = FactoryBot.build(:bar, :name => 'Intro')
 
       dsl.add bar
 
-      dsl.node.children.should have(1).bar
-      dsl.node.children[0].should == bar
+      expect(dsl.node.children.size).to eq(1)
+      expect(dsl.node.children[0]).to eq(bar)
     end
 
     it "should add the definition_children in the block to the child" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
-      bar = FactoryGirl.build(:bar, :children => [])
-      note_set = FactoryGirl.build(:note_set)
+      bar = FactoryBot.build(:bar, :children => [])
+      note_set = FactoryBot.build(:note_set)
 
       dsl.add bar do
         add note_set
       end
 
-      dsl.node.children.should have(1).bar
-      dsl.node.children[0].should == bar
+      expect(dsl.node.children.size).to eq(1)
+      expect(dsl.node.children[0]).to eq(bar)
 
-      bar.children.should have(1).note_set
-      bar.children[0].should == note_set
+      expect(bar.children.size).to eq(1)
+      expect(bar.children[0]).to eq(note_set)
     end
   end
 
   describe "#notes" do
     it "should add a note set with the value" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:bar, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:bar, :children => []))
+      expect(dsl.node.children).to be_empty
 
       dsl.notes 'test'
 
-      dsl.node.children.should have(1).note_set
-      dsl.node.children[0].value.should == 'test'
+      expect(dsl.node.children.size).to eq(1)
+      expect(dsl.node.children[0].value).to eq('test')
     end
   end
 
   describe "#line" do
     it "should add a line with the name" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
       dsl.line 'Intro'
 
-      dsl.node.children.should have(1).line
+      expect(dsl.node.children.size).to eq(1)
 
       line = dsl.node.children[0]
-      line.name.should == 'Intro'
-      line.children.should be_empty
+      expect(line.name).to eq('Intro')
+      expect(line.children).to be_empty
     end
 
     it "should add the definition_children declared in the block to the line" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
-      bar = FactoryGirl.build(:bar)
+      bar = FactoryBot.build(:bar)
 
       dsl.line 'Intro' do
         add bar
       end
 
-      dsl.node.children.should have(1).line
-      dsl.node.children[0].name.should == 'Intro'
+      expect(dsl.node.children.size).to eq(1)
+      expect(dsl.node.children[0].name).to eq('Intro')
 
       line = dsl.node.children[0]
-      line.children.should have(1).bar
-      line.children[0].should == bar
+      expect(line.children.size).to eq(1)
+      expect(line.children[0]).to eq(bar)
     end
     
     it "should allow breaking to be toggled" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
       dsl.line :manual_break => false
       
-      dsl.node.children.should have(1).line
-      dsl.node.children[0].name.should == 'TabOneLineOne' # not manual_breaking=false
-      dsl.node.children[0].manual_break?.should be_false
+      expect(dsl.node.children.size).to eq(1)
+      expect(dsl.node.children[0].name).to eq('TabOneLineOne') # not manual_breaking=false
+      expect(dsl.node.children[0].manual_break?).to be_falsy
     end
   end
 
   describe "#add_names" do
     it "should add a node with o[:name] of o[:node_class] to the node" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
       dsl.add_names :names => [:Intro, :Intro], :node_class => Node::Bar
 
-      dsl.node.children.should have(2).bars
+      expect(dsl.node.children.size).to eq(2)
       dsl.node.children.each do |child|
-        child.should be_a(Node::Bar)
-        child.name.should == :Intro
+        expect(child).to be_a(Node::Bar)
+        expect(child.name).to eq(:Intro)
       end
     end
 
     it "should add a node with nil name if the o[:names] is blank" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
       dsl.add_names :names => [], :node_class => Node::Bar
 
-      dsl.node.children.should have(1).bar
-      dsl.node.children[0].attributes[:name].should be_nil
-      dsl.node.children[0].should be_a(Node::Bar)
+      expect(dsl.node.children.size).to eq(1)
+      expect(dsl.node.children[0].attributes[:name]).to be_nil
+      expect(dsl.node.children[0]).to be_a(Node::Bar)
     end
     
     it "should set o[:options] as attributes of the nodes" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
       dsl.add_names :names => [:Intro, :Intro], :options => {:value => 1 }, :node_class => Node::Base
 
-      dsl.node.children.should have(2).nodes
+      expect(dsl.node.children.size).to eq(2)
       dsl.node.children.each do |child|
-        child.name.should == :Intro
-        child.value.should == 1
+        expect(child.name).to eq(:Intro)
+        expect(child.value).to eq(1)
       end
     end
   end
 
   describe "#score" do
     it "should add a score with the name" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
       dsl.score
 
-      dsl.node.children.should have(1).score
+      expect(dsl.node.children.size).to eq(1)
 
       score = dsl.node.children[0]
-      score.should be_a(Node::Score)
-      score.children.should be_empty
+      expect(score).to be_a(Node::Score)
+      expect(score.children).to be_empty
     end
 
     it "should add the definition_children declared in the block to the score" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
-      note_set = FactoryGirl.build(:note_set)
+      note_set = FactoryBot.build(:note_set)
 
       dsl.score do
         add note_set
       end
 
-      dsl.node.children.should have(1).score
+      expect(dsl.node.children.size).to eq(1)
 
       score = dsl.node.children[0]
-      score.children.should have(1).note_set
-      score.children[0].should == note_set
+      expect(score.children.size).to eq(1)
+      expect(score.children[0]).to eq(note_set)
     end
   end
 
   describe "#stanza" do
     it "should add a stanza with the name" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
       dsl.stanza 'Intro'
 
-      dsl.node.children.should have(1).stanza
+      expect(dsl.node.children.size).to eq(1)
 
       stanza = dsl.node.children[0]
-      stanza.name.should == 'Intro'
-      stanza.children.should be_empty
+      expect(stanza.name).to eq('Intro')
+      expect(stanza.children).to be_empty
     end
 
     it "should add the definition_children declared in the block to the stanza" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
-      line = FactoryGirl.build(:line)
+      line = FactoryBot.build(:line)
 
       dsl.stanza 'Intro' do
         add line
       end
 
-      dsl.node.children.should have(1).stanza
-      dsl.node.children[0].name.should == 'Intro'
+      expect(dsl.node.children.size).to eq(1)
+      expect(dsl.node.children[0].name).to eq('Intro')
 
       stanza = dsl.node.children[0]
-      stanza.children.should have(1).line
-      stanza.children[0].should == line
+      expect(stanza.children.size).to eq(1)
+      expect(stanza.children[0]).to eq(line)
     end
   end
 
   [:title, :composer, :arranger, :instrument, :key, :midi_instrument, :string_tunings, :tempo, :transposition].each do |property|
     describe "##{property}" do
       it "should set the #{property} of the tab to value" do
-        tab = FactoryGirl.build(:tab)
+        tab = FactoryBot.build(:tab)
 
-        dsl = FactoryGirl.build(:dsl, :node => tab)
+        dsl = FactoryBot.build(:dsl, :node => tab)
         dsl.send property, "test"
 
-        tab.send(property).should == "test"
+        expect(tab.send(property)).to eq("test")
       end
     end
   end
 
   describe "#chords" do
     it "should add a chord set with the name" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
       dsl.chords :Am, 'r4-"Am" r r r'
 
-      dsl.node.children.should have(1).chord_set
+      expect(dsl.node.children.size).to eq(1)
 
       chord_set = dsl.node.children[0]
-      chord_set.name.should == :Am
-      chord_set.value.should == 'r4-"Am" r r r'
+      expect(chord_set.name).to eq(:Am)
+      expect(chord_set.value).to eq('r4-"Am" r r r')
     end
   end
 
   describe "#chords" do
     it "should add a bar with the name" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      dsl.node.children.should be_empty
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      expect(dsl.node.children).to be_empty
 
       dsl.chords :Am
 
-      dsl.node.children.should have(1).chord_set
+      expect(dsl.node.children.size).to eq(1)
 
       chord_set = dsl.node.children[0]
-      chord_set.name.should == :Am
+      expect(chord_set.name).to eq(:Am)
     end
   end
 
   describe "#partial" do
     it "should set the specified duration of the bar node to duration" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:bar))
-      dsl.node.specified_duration.should be_nil
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:bar))
+      expect(dsl.node.specified_duration).to be_nil
 
       dsl.partial 8
 
-      dsl.node.specified_duration.should == 8
+      expect(dsl.node.specified_duration).to eq(8)
     end
   end
 
   describe "#repeat" do
     it "should add a repeat with the value" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
 
       dsl.repeat 2
 
-      dsl.node.children.should have(1).repeat
+      expect(dsl.node.children.size).to eq(1)
 
       repeat = dsl.node.children[0]
-      repeat.value.should == 2
-      repeat.children.should be_empty
+      expect(repeat.value).to eq(2)
+      expect(repeat.children).to be_empty
     end
 
     it "should add the children declared in the block to the repeat" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
 
-      bar = FactoryGirl.build(:bar)
+      bar = FactoryBot.build(:bar)
 
       dsl.repeat 2 do
         add bar
       end
 
-      dsl.node.children.should have(1).repeat
+      expect(dsl.node.children.size).to eq(1)
 
       repeat = dsl.node.children[0]
-      repeat.children.should have(1).child
-      repeat.children[0].should == bar
+      expect(repeat.children.size).to eq(1)
+      expect(repeat.children[0]).to eq(bar)
     end
   end
 
   describe "#alternative" do
     it "should add the children declared in the block to the alternative" do
-      dsl = FactoryGirl.build(:dsl, :node => FactoryGirl.build(:tab, :children => []))
-      bar = FactoryGirl.build(:bar)
+      dsl = FactoryBot.build(:dsl, :node => FactoryBot.build(:tab, :children => []))
+      bar = FactoryBot.build(:bar)
 
       dsl.alternative do
         add bar
       end
 
-      dsl.node.children.should have(1).alternative
+      expect(dsl.node.children.size).to eq(1)
 
       alternative = dsl.node.children[0]
-      alternative.children.should have(1).child
-      alternative.children[0].should == bar
+      expect(alternative.children.size).to eq(1)
+      expect(alternative.children[0]).to eq(bar)
     end
   end
 end

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

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Gitara::Node::Alternative do
   describe "#call_value" do
     it "should be a call to lilypond's alternative command" do
-      alternative = FactoryGirl.build(:alternative, :children => [
-        FactoryGirl.build(:bar, :name => 'First'),
-        FactoryGirl.build(:bar, :name => 'Second')
+      alternative = FactoryBot.build(:alternative, :children => [
+        FactoryBot.build(:bar, :name => 'First'),
+        FactoryBot.build(:bar, :name => 'Second')
       ])
 
       version = Node::Base::NodeVersion.new(:node => alternative)
-      alternative.call_value(version).should == "\\alternative { { \\nBarFirst } { \\nBarSecond } }"
+      expect(alternative.call_value(version)).to eq("\\alternative { { \\nBarFirst } { \\nBarSecond } }")
     end
   end
 end

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

@@ -3,17 +3,17 @@ require 'spec_helper'
 describe Gitara::Node::Bar::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"')])
+      bar = FactoryBot.build(:bar, :children => [FactoryBot.build(:chord_set, :name => :Am, :value => 'r-"Am"')])
 
-      chorded_bar = FactoryGirl.build(:chorded_bar, :node => bar)
-      chorded_bar.value.should == '\cChordSetAm'
+      chorded_bar = FactoryBot.build(:chorded_bar, :node => bar)
+      expect(chorded_bar.value).to eq('\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')])
+      bar = FactoryBot.build(:bar, :children => [FactoryBot.build(:note_set, :value => 'c')])
 
-      chorded_bar = FactoryGirl.build(:chorded_bar, :node => bar)
-      chorded_bar.value.should == ""
+      chorded_bar = FactoryBot.build(:chorded_bar, :node => bar)
+      expect(chorded_bar.value).to eq("")
     end
   end
 end

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

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe Gitara::Node::Bar::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])
-      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_version_of_bar = FactoryGirl.build(:stanza_version_bar, :node => bar)
-      stanza_version_of_bar.value.should == 'r1'
+      stanza_version_of_bar = FactoryBot.build(:stanza_version_bar, :node => bar)
+      expect(stanza_version_of_bar.value).to eq('r1')
     end
   end
 end

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

@@ -3,14 +3,14 @@ require 'spec_helper'
 describe Gitara::Node::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)
+      note_set = FactoryBot.build(:note_set)
 
-      bar = FactoryGirl.build(:bar, :children => [note_set])
+      bar = FactoryBot.build(:bar, :children => [note_set])
 
-      voice = FactoryGirl.build(:voice, :id => 1)
+      voice = FactoryBot.build(:voice, :id => 1)
 
-      voiced_bar = FactoryGirl.build(:voiced_bar, :node => bar, :voice => voice)
-      voiced_bar.matching_note_set.should == note_set
+      voiced_bar = FactoryBot.build(:voiced_bar, :node => bar, :voice => voice)
+      expect(voiced_bar.matching_note_set).to eq(note_set)
     end
   end
 end

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

@@ -3,50 +3,50 @@ require 'spec_helper'
 describe Gitara::Node::Bar do
   describe "#note_sets" do
     it "should be the note sets of its definition" 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.note_sets.should have(2).note_sets
+      expect(call_bar.note_sets.size).to eq(2)
     end
   end
 
   describe "#stanza_heading" do
     it "should be a whole rest with no stanza name" do
-      first_bar = FactoryGirl.build(:bar)
-      second_bar = FactoryGirl.build(:bar)
-      stanza = FactoryGirl.build(:stanza, :name => 'Intro', :children => [first_bar, second_bar])
-      tab = FactoryGirl.build(:tab, :children => [stanza], :time => '4/4')
+      first_bar = FactoryBot.build(:bar)
+      second_bar = FactoryBot.build(:bar)
+      stanza = FactoryBot.build(:stanza, :name => 'Intro', :children => [first_bar, second_bar])
+      tab = FactoryBot.build(:tab, :children => [stanza], :time => '4/4')
 
-      second_bar.stanza_heading.should == 'r1'
+      expect(second_bar.stanza_heading).to eq('r1')
     end
 
     it "should be a partial with no stanza name if the bar has a special_duration" do
-      first_bar = FactoryGirl.build(:bar)
-      second_bar = FactoryGirl.build(:bar, :specified_duration => 8)
-      stanza = FactoryGirl.build(:stanza, :name => 'Intro', :children => [first_bar, second_bar])
-      tab = FactoryGirl.build(:tab, :children => [stanza], :time => '4/4')
+      first_bar = FactoryBot.build(:bar)
+      second_bar = FactoryBot.build(:bar, :specified_duration => 8)
+      stanza = FactoryBot.build(:stanza, :name => 'Intro', :children => [first_bar, second_bar])
+      tab = FactoryBot.build(:tab, :children => [stanza], :time => '4/4')
 
-      second_bar.stanza_heading.should == 'r8'
+      expect(second_bar.stanza_heading).to eq('r8')
     end
   end
 
   describe "#specified_duration_as_lilypond" do
     it "should be \\partial specified_duration if present" do
-      bar = FactoryGirl.build(:bar, :specified_duration => 8)
-      bar.specified_duration_as_lilypond.should == '\partial 8'
+      bar = FactoryBot.build(:bar, :specified_duration => 8)
+      expect(bar.specified_duration_as_lilypond).to eq('\partial 8')
     end
 
     it "should be nil if there is no specified_duration" do
-      bar = FactoryGirl.build(:bar, :specified_duration => nil)
-      bar.specified_duration_as_lilypond.should be_nil
+      bar = FactoryBot.build(:bar, :specified_duration => nil)
+      expect(bar.specified_duration_as_lilypond).to be_nil
     end
   end
 end