csl 1.2.1 → 1.2.2

data/spec/csl/style/choose_spec.rb

@@ -11,21 +11,21 @@ module CSL
       
       describe '#conditions' do
         it 'returns an empty list by default' do
-          Choose::Block.new.conditions.should be_empty
+          expect(Choose::Block.new.conditions).to be_empty
         end
         
         describe 'when the node has a single condition' do
           let(:node) { Choose::Block.new(:'is-numeric' => 'edition' )}
           
           it 'returns an array with an array containing the type, matcher and values of the condition' do
-            node.conditions.should == [[:'is-numeric', :all?, ['edition']]]
+            expect(node.conditions).to eq([[:'is-numeric', :all?, ['edition']]])
           end
 
           describe 'when the condition has multiple values' do
             before { node[:'is-numeric'] << ' issue' }
             
             it 'it splits the values in the conditions list' do
-              node.conditions.should == [[:'is-numeric', :all?, ['edition', 'issue']]]
+              expect(node.conditions).to eq([[:'is-numeric', :all?, ['edition', 'issue']]])
             end
           end
           
@@ -33,12 +33,12 @@ module CSL
             before { node[:disambiguate] = 'true' }
             
             it 'returns an array with two elements' do
-              node.conditions.should have_exactly(2).items
+              expect(node.conditions.size).to eq(2)
             end
             
             it 'returns both conditions as arrays' do
-              node.conditions.map(&:first).sort.should == [:disambiguate, :'is-numeric']
-              node.conditions.map(&:last).sort.should == [['edition'], ['true']]
+              expect(node.conditions.map(&:first).sort).to eq([:disambiguate, :'is-numeric'])
+              expect(node.conditions.map(&:last).sort).to eq([['edition'], ['true']])
             end
           end
         end
@@ -47,14 +47,14 @@ module CSL
           let(:node) { Choose::Block.new(:'variable-any' => 'author editor' )}
           
           it 'strips the match override from the type name and inserts it as the matcher' do
-            node.conditions.should == [[:variable, :any?, ['author', 'editor']]]
+            expect(node.conditions).to eq([[:variable, :any?, ['author', 'editor']]])
           end
           
           describe 'other conditions' do
             before { node[:position] = 'false' }
             
             it 'are not affected by the override' do
-              node.conditions.map { |c| c[1].to_s }.sort.should == %w{ all? any? }
+              expect(node.conditions.map { |c| c[1].to_s }.sort).to eq(%w{ all? any? })
             end
           end
         end

data/spec/csl/style/date_spec.rb

@@ -9,11 +9,11 @@ module CSL
 
     describe '#numeric-leading-zeros?' do
       
-      it { should_not be_numeric_leading_zeros }
+      it { is_expected.not_to be_numeric_leading_zeros }
       
       it 'returns true when the form is set accordingly' do
         subject[:form] = 'numeric-leading-zeros'
-        subject.should be_numeric_leading_zeros
+        expect(subject).to be_numeric_leading_zeros
       end
     end
 

data/spec/csl/style/label_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 module CSL
   describe Style::Label do
 
-    it { should_not be_names_label }
-    it { should_not be_always_pluralize }
-    it { should_not be_never_pluralize }
+    it { is_expected.not_to be_names_label }
+    it { is_expected.not_to be_always_pluralize }
+    it { is_expected.not_to be_never_pluralize }
 
     describe '.terms' do
       Hash[*%w{
@@ -17,7 +17,7 @@ module CSL
         chapter-number    chapter
       }].each do |variable, term|
         it "returns #{term.inspect} for #{variable.inspect}" do
-          Style::Label.terms[variable].should == term
+          expect(Style::Label.terms[variable]).to eq(term)
         end
       end
     end
@@ -25,18 +25,18 @@ module CSL
     describe 'a label inside a names node' do
       before(:each) { Style::Names.new << subject }
 
-      it { should be_names_label }
+      it { is_expected.to be_names_label }
     end
 
     describe '#term' do
-      it { should be_empty }
+      it { is_expected.to be_empty }
 
       it 'returns the term for the current variable' do
         subject[:variable] = 'page'
-        subject.term.should == 'page'
+        expect(subject.term).to eq('page')
 
         subject[:variable] = 'number-of-volumes'
-        subject.term.should == 'volume'
+        expect(subject.term).to eq('volume')
       end
     end
 

data/spec/csl/style/names_spec.rb

@@ -7,7 +7,7 @@ module CSL
 
   describe Style::Name do
 
-    it { should be_delimiter_contextually_precedes_last }
+    it { is_expected.to be_delimiter_contextually_precedes_last }
 
     [:never, :always, :contextually].each do |setting|
       setter = "delimiter_#{setting}_precedes_last!"
@@ -15,7 +15,7 @@ module CSL
 
       describe "##{setter}" do
         it 'sets the delimiter precedes last option accordingly' do
-          subject.send(setter).send(predicate).should == true
+          expect(subject.send(setter).send(predicate)).to eq(true)
         end
       end
     end

data/spec/csl/style/number_spec.rb

@@ -5,79 +5,79 @@ module CSL
   
     describe '.new' do
       it 'returns an empty number tag by default' do
-        Style::Number.new.should_not have_attributes
+        expect(Style::Number.new).not_to have_attributes
       end
       
       it 'accepts a form attribute' do
-        Style::Number.new(:form => 'roman').should be_roman
+        expect(Style::Number.new(:form => 'roman')).to be_roman
       end
     end
     
     describe '#numeric?' do
       it 'returns true by default' do
-        Style::Number.new.should be_numeric
+        expect(Style::Number.new).to be_numeric
       end
       
       it 'returns false if the form attribute is set to a value other than :numeric' do
-        Style::Number.new(:form => 'foo').should_not be_numeric
+        expect(Style::Number.new(:form => 'foo')).not_to be_numeric
       end
       
       it 'returns false if the form attribute is set to :numeric' do
-        Style::Number.new(:form => 'numeric').should be_numeric
+        expect(Style::Number.new(:form => 'numeric')).to be_numeric
       end
     end
 
     describe '#roman?' do
       it 'returns false by default' do
-        Style::Number.new.should_not be_roman
+        expect(Style::Number.new).not_to be_roman
       end
       
       it 'returns false if the form attribute is set to a value other than :numeric' do
-        Style::Number.new(:form => 'ordinal').should_not be_roman
+        expect(Style::Number.new(:form => 'ordinal')).not_to be_roman
       end
       
       it 'returns false if the form attribute is set to :roman' do
-        Style::Number.new(:form => 'roman').should be_roman
+        expect(Style::Number.new(:form => 'roman')).to be_roman
       end
     end
 
     describe '#ordinal?' do
       it 'returns false by default' do
-        Style::Number.new.should_not be_ordinal
+        expect(Style::Number.new).not_to be_ordinal
       end
       
       it 'returns false if the form attribute is set to a value other than :ordinal' do
-        Style::Number.new(:form => 'long-ordinal').should_not be_ordinal
+        expect(Style::Number.new(:form => 'long-ordinal')).not_to be_ordinal
       end
       
       it 'returns false if the form attribute is set to :ordinal' do
-        Style::Number.new(:form => 'ordinal').should be_ordinal
-        Style::Number.new(:form => :ordinal).should be_ordinal
+        expect(Style::Number.new(:form => 'ordinal')).to be_ordinal
+        expect(Style::Number.new(:form => :ordinal)).to be_ordinal
       end
     end
 
     describe '#long_ordinal?' do
       it 'returns false by default' do
-        Style::Number.new.should_not be_long_ordinal
+        expect(Style::Number.new).not_to be_long_ordinal
       end
       
       it 'returns false if the form attribute is set to a value other than :"long-ordinal"' do
-        Style::Number.new(:form => 'ordinal').should_not be_long_ordinal
+        expect(Style::Number.new(:form => 'ordinal')).not_to be_long_ordinal
       end
       
       it 'returns false if the form attribute is set to :ordinal' do
-        Style::Number.new(:form => 'long-ordinal').should be_long_ordinal
+        expect(Style::Number.new(:form => 'long-ordinal')).to be_long_ordinal
       end
     end
 
     
     describe '#to_xml' do
       it 'returns an empty number tag by default' do
-        Style::Number.new.to_xml.should == '<number/>'
+        expect(Style::Number.new.to_xml).to eq('<number/>')
       end
       
       it 'returns a tag with a all attribute assignments' do
-        Style::Number.new(:form => 'roman').to_xml.should == '<number form="roman"/>'
+        expect(Style::Number.new(:form => 'roman').to_xml).to eq('<number form="roman"/>')
       end
     end
     

data/spec/csl/style/sort_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module CSL
   describe Style::Sort do
-    it { should_not have_sort_keys }
+    it { is_expected.not_to have_sort_keys }
   end
 
   describe Style::Sort::Key do

data/spec/csl/style_spec.rb

@@ -7,78 +7,78 @@ module CSL
     end
 
     it 'has a 1.x version by default' do
-      @style[:version].should match(/1\.\d+(\.\d+)?/)
+      expect(@style[:version]).to match(/1\.\d+(\.\d+)?/)
     end
 
     it 'has the default version' do
-      @style.default_attribute?(:version).should be_true
+      expect(@style.default_attribute?(:version)).to be_truthy
     end
 
     it 'has a the default namespace attribute' do
-      @style[:xmlns].should == CSL::Schema.namespace
-      @style.default_attribute?(:xmlns).should be_true
+      expect(@style[:xmlns]).to eq(CSL::Schema.namespace)
+      expect(@style.default_attribute?(:xmlns)).to be_truthy
     end
 
     describe '#to_xml' do
       it 'returns an empty style' do
-        @style.to_xml.should match(/^<style[^>]*\/>/)
+        expect(@style.to_xml).to match(/^<style[^>]*\/>/)
       end
 
       it 'includes the xml namespace' do
-        @style.to_xml.should match(CSL::Schema.namespace)
+        expect(@style.to_xml).to match(CSL::Schema.namespace)
       end
 
       it 'supports round-trip for apa style' do
         apa = Style.load(:apa)
-        apa.should be_a(Style)
+        expect(apa).to be_a(Style)
 
         xml = apa.to_xml
-        xml.should match(/^<style[^>]*>/)
+        expect(xml).to match(/^<style[^>]*>/)
 
-        Style.parse(xml).should be_a(Style)
+        expect(Style.parse(xml)).to be_a(Style)
       end
     end
 
     describe '#deep_copy' do
       it 'works on apa style' do
         apa = Style.load(:apa)
-        apa.should be_a(Style)
+        expect(apa).to be_a(Style)
 
         xml = apa.to_xml
 
         copy = apa.deep_copy
 
-        apa.to_xml.should == xml # original unchanged!
-        copy.to_xml.should == xml
+        expect(apa.to_xml).to eq(xml) # original unchanged!
+        expect(copy.to_xml).to eq(xml)
       end
     end
 
     describe '#children' do
 
-      it { should_not have_info }
-      it { should_not have_locale }
-      it { should_not have_macro }
-      it { should_not have_citation }
-      it { should_not have_bibliography }
+      it { is_expected.not_to have_info }
+      it { is_expected.not_to have_locale }
+      it { is_expected.not_to have_macro }
+      it { is_expected.not_to have_citation }
+      it { is_expected.not_to have_bibliography }
 
       describe 'when it has a title' do
         before { @style.title = 'foo' }
 
-        it { @style.should have_info }
+        it { expect(@style).to have_info }
 
         it 'info.title is a text node' do
-          @style.info.title.should be_a(TextNode)
+          expect(@style.info.title).to be_a(TextNode)
         end
 
         it '#title returns the title as a string' do
-          @style.title.should be_a(String)
+          expect(@style.title).to be_a(String)
         end
       end
     end
 
     describe '#id accessor' do
       it 'returns nil by default' do
-        @style.id.should be_nil
+        expect(@style.id).to be_nil
       end
 
       it 'writer sets the id to the passed-in string' do
@@ -88,11 +88,11 @@ module CSL
 
     describe 'independent and dependent styles' do
       it 'styles are independent by default' do
-        @style.should be_independent
+        expect(@style).to be_independent
       end
 
       it 'styles do not have independent-parent links by default' do
-        @style.should_not have_independent_parent_link
+        expect(@style).not_to have_independent_parent_link
       end
 
       it 'when setting an independet-parent link a style becomes dependent' do
@@ -102,7 +102,7 @@ module CSL
 
     describe 'macros' do
       it 'has no macros by default' do
-        @style.should_not have_macros
+        expect(@style).not_to have_macros
       end
 
       it 'raises a validation error when adding a macro without name' do
@@ -113,12 +113,12 @@ module CSL
         before { @style << Style::Macro.new(:name => 'author') }
 
         it 'has macros' do
-          @style.should have_macros
+          expect(@style).to have_macros
         end
 
         it 'the macro is registered in the macros hash' do
-          @style.macros.should have_key('author')
-          @style.macros['author'].should be_a(Style::Macro)
+          expect(@style.macros).to have_key('author')
+          expect(@style.macros['author']).to be_a(Style::Macro)
         end
 
         it 'raises a validation error when adding a macro with a duplicate name' do

data/spec/csl/treelike_spec.rb

@@ -19,17 +19,17 @@ module CSL
     let(:lvl2) { TestTree.new.add_child(TestTree.new).add_child(TestTree.new) }
 
     it 'has no children by default' do
-      node.should_not have_children
+      expect(node).not_to have_children
     end
     
     it 'is empty by default' do
-      node.should be_empty
+      expect(node).to be_empty
     end
     
     describe '#children' do
       
       it 'is empty by default' do
-        node.children.should be_empty
+        expect(node.children).to be_empty
       end
       
       it 'grows when adding child nodes' do
@@ -40,58 +40,58 @@ module CSL
     
 	  describe '#nodename' do
 	    it 'returns the class name in attribute form by default' do
-	      node.nodename.should == 'test-tree'
+	      expect(node.nodename).to eq('test-tree')
 	    end
 	  end
     
 	  describe '#ancestors' do
       it 'returns and empty list by default' do
-        node.ancestors.should be_empty
+        expect(node.ancestors).to be_empty
       end
 
       it 'returns a list with one ancestor at level 1' do
-        lvl1.ancestors.should have(1).element
+        expect(lvl1.ancestors.size).to eq(1)
       end
         
       it 'the last ancestor is also the root node at levels 1 and deeper' do
-        lvl1.ancestors.last.should be_root
-        lvl2.ancestors.last.should be_root
+        expect(lvl1.ancestors.last).to be_root
+        expect(lvl2.ancestors.last).to be_root
       end
 
       it 'returns a list with two ancestors at level 2' do
-        lvl2.ancestors.should have(2).elements
+        expect(lvl2.ancestors.size).to eq(2)
       end      
 	  end
 
     it 'is a root node by default' do
-      node.should be_root
+      expect(node).to be_root
     end
     
 	  describe '#root' do  
 	    it 'returns self at level 0' do
-	      node.root.should equal(node)
+	      expect(node.root).to equal(node)
 	    end
 
       it 'returns the parent at level 1' do
-        lvl1.root.should == lvl1.parent
+        expect(lvl1.root).to eq(lvl1.parent)
       end
 
       it 'returns parent.parent at level 2' do
-        lvl2.root.should == lvl2.parent.parent
+        expect(lvl2.root).to eq(lvl2.parent.parent)
       end
 	  end
     
     describe '#depth' do
       it 'returns 0 by default' do
-        node.depth.should == 0
+        expect(node.depth).to eq(0)
       end
 
       it 'returns 1 at level 1' do
-        lvl1.depth.should == 1
+        expect(lvl1.depth).to eq(1)
       end
 
       it 'returns 2 at level 2' do
-        lvl2.depth.should == 2
+        expect(lvl2.depth).to eq(2)
       end
       
       it 'grows when the node is added to another node' do
@@ -111,23 +111,23 @@ module CSL
       end
     
       it 'the class contains a children struct' do
-        TestTree.const?(:Children).should be true
+        expect(TestTree.const?(:Children)).to be true
       end
       
       describe '.create_children' do
         it 'returns the children struct' do
-          TestTree.create_children.should be_a(Struct)
+          expect(TestTree.create_children).to be_a(Struct)
         end
       end
       
       describe '#children' do
         it 'returns a children struct instance' do
-          TestTree.new.children.should be_a(Struct)
+          expect(TestTree.new.children).to be_a(Struct)
         end
       end
       
       it 'has no children by default' do
-        TestTree.new.should_not have_children
+        expect(TestTree.new).not_to have_children
       end
       
       it 'has children when adding child nodes' do