csl 1.2.1 → 1.2.2

data/spec/csl/node_spec.rb

@@ -4,9 +4,9 @@ module CSL
 
 	describe Node do
 
-    it { should_not be nil }
-    it { should_not have_children }
-    it { should_not have_attributes }
+    it { is_expected.not_to be nil }
+    it { is_expected.not_to have_children }
+    it { is_expected.not_to have_attributes }
 
 		describe 'given a FooBarNode with attributes :foo and :bar and a TestNode without defined attributes' do
       before(:all) do
@@ -18,126 +18,126 @@ module CSL
       end
 
       it 'creates FooBarNode::Attributes' do
-        FooBarNode.const_defined?(:Attributes).should be_true
+        expect(FooBarNode.const_defined?(:Attributes)).to be_truthy
       end
 
       it 'does not create TestNode::Attributes' do
-        TestNode.const_defined?(:Attributes).should_not be_true
+        expect(TestNode.const_defined?(:Attributes)).not_to be_truthy
       end
 
 		  it 'TestNode attributes are a regular Hash' do
-		    TestNode.new.attributes.should be_a(Hash)
+		    expect(TestNode.new.attributes).to be_a(Hash)
 		  end
 
 		  it 'FooBarNode attributes are a Struct' do
-		    FooBarNode.new.attributes.should be_a(Struct)
+		    expect(FooBarNode.new.attributes).to be_a(Struct)
 		  end
 
 		  describe '#match?' do
 		    it 'matches an empty query' do
-		      FooBarNode.new.match?({}).should be_true
-		      FooBarNode.new(:foo => 'Foo').match?({}).should be_true
-		      TestNode.new.match?({}).should be_true
-		      TestNode.new(:foo => 'Foo').match?({}).should be_true
+		      expect(FooBarNode.new.match?({})).to be_truthy
+		      expect(FooBarNode.new(:foo => 'Foo').match?({})).to be_truthy
+		      expect(TestNode.new.match?({})).to be_truthy
+		      expect(TestNode.new(:foo => 'Foo').match?({})).to be_truthy
 		    end
 
         it 'returns true for a matching query' do
-		      FooBarNode.new(:foo => 'bar').match?(:foo => 'bar').should be_true
-		      FooBarNode.new(:bar => 'b', :foo => 'f').match?(:foo => 'f', :bar => 'b').should be_true
+		      expect(FooBarNode.new(:foo => 'bar').match?(:foo => 'bar')).to be_truthy
+		      expect(FooBarNode.new(:bar => 'b', :foo => 'f').match?(:foo => 'f', :bar => 'b')).to be_truthy
         end
 
         it 'returns false for non-matching query' do
-		      FooBarNode.new.match?(:foo => 'bar').should be_false
-		      FooBarNode.new(:foo => 'f').match?(:foo => 'f', :bar => 'b').should be_false
+		      expect(FooBarNode.new.match?(:foo => 'bar')).to be_falsey
+		      expect(FooBarNode.new(:foo => 'f').match?(:foo => 'f', :bar => 'b')).to be_falsey
         end
 
         it 'returns false if the query contains unknown attributes' do
-		      FooBarNode.new(:foo => 'f').match?(:foo => 'f', :unknown => 'u').should be_false
+		      expect(FooBarNode.new(:foo => 'f').match?(:foo => 'f', :unknown => 'u')).to be_falsey
         end
 
         it 'matches irrespective of order' do
-		      FooBarNode.new(:bar => 'b', :foo => 'f').match?(:foo => 'f', :bar => 'b').should be_true
-		      FooBarNode.new(:foo => 'f', :bar => 'b').match?(:foo => 'f', :bar => 'b').should be_true
-		      FooBarNode.new(:foo => 'f', :bar => 'b').match?(:bar => 'b', :foo => 'f').should be_true
-		      FooBarNode.new(:bar => 'b', :foo => 'f').match?(:bar => 'b', :foo => 'f').should be_true
+		      expect(FooBarNode.new(:bar => 'b', :foo => 'f').match?(:foo => 'f', :bar => 'b')).to be_truthy
+		      expect(FooBarNode.new(:foo => 'f', :bar => 'b').match?(:foo => 'f', :bar => 'b')).to be_truthy
+		      expect(FooBarNode.new(:foo => 'f', :bar => 'b').match?(:bar => 'b', :foo => 'f')).to be_truthy
+		      expect(FooBarNode.new(:bar => 'b', :foo => 'f').match?(:bar => 'b', :foo => 'f')).to be_truthy
         end
 
 		    it 'matches an empty query with the correct node name' do
-		      FooBarNode.new.match?('foo-bar-node', {}).should be_true
-		      FooBarNode.new(:foo => 'Foo').match?('foo-bar-node', {}).should be_true
-		      TestNode.new.match?('test-node', {}).should be_true
-		      TestNode.new(:foo => 'Foo').match?('test-node', {}).should be_true
+		      expect(FooBarNode.new.match?('foo-bar-node', {})).to be_truthy
+		      expect(FooBarNode.new(:foo => 'Foo').match?('foo-bar-node', {})).to be_truthy
+		      expect(TestNode.new.match?('test-node', {})).to be_truthy
+		      expect(TestNode.new(:foo => 'Foo').match?('test-node', {})).to be_truthy
 		    end
 
 		    it 'does not match other node names' do
-		      FooBarNode.new.match?(:name, {}).should_not be_true
-		      FooBarNode.new(:foo => 'Foo').match?(:name, {}).should_not be_true
-		      TestNode.new.match?(:name, {}).should_not be_true
-		      TestNode.new(:foo => 'Foo').match?(:name, {}).should_not be_true
+		      expect(FooBarNode.new.match?(:name, {})).not_to be_truthy
+		      expect(FooBarNode.new(:foo => 'Foo').match?(:name, {})).not_to be_truthy
+		      expect(TestNode.new.match?(:name, {})).not_to be_truthy
+		      expect(TestNode.new(:foo => 'Foo').match?(:name, {})).not_to be_truthy
 		    end
 		  end
 
 		  describe '#attributes_for' do
 		    it 'returns an empty hash when there no attributes are set' do
-		      TestNode.new.attributes_for.should be_empty
-		      TestNode.new.attributes_for(:x, :y).should be_empty
+		      expect(TestNode.new.attributes_for).to be_empty
+		      expect(TestNode.new.attributes_for(:x, :y)).to be_empty
 
-		      FooBarNode.new.attributes_for.should be_empty
-		      FooBarNode.new.attributes_for(:x, :y).should be_empty
-		      FooBarNode.new.attributes_for(:foo, :bar).should be_empty
+		      expect(FooBarNode.new.attributes_for).to be_empty
+		      expect(FooBarNode.new.attributes_for(:x, :y)).to be_empty
+		      expect(FooBarNode.new.attributes_for(:foo, :bar)).to be_empty
 		    end
 
 		    it 'returns an empty hash when no attributes match the filter' do
-		      TestNode.new(:foo => 'foo').attributes_for.should be_empty
-		      TestNode.new(:foo => 'foo').attributes_for(:x, :y).should be_empty
+		      expect(TestNode.new(:foo => 'foo').attributes_for).to be_empty
+		      expect(TestNode.new(:foo => 'foo').attributes_for(:x, :y)).to be_empty
 
-		      FooBarNode.new(:foo => 'foo').attributes_for.should be_empty
-		      FooBarNode.new(:foo => 'foo').attributes_for(:x, :y).should be_empty
+		      expect(FooBarNode.new(:foo => 'foo').attributes_for).to be_empty
+		      expect(FooBarNode.new(:foo => 'foo').attributes_for(:x, :y)).to be_empty
 		    end
 
 		    it 'returns a hash of all set attributes that match the filter' do
-		      TestNode.new(:foo => 'foo', :bar => 'bar').attributes_for(:x, :foo).should == { :foo => 'foo' }
-		      FooBarNode.new(:foo => 'foo', :bar => 'bar').attributes_for(:x, :foo).should == { :foo => 'foo' }
+		      expect(TestNode.new(:foo => 'foo', :bar => 'bar').attributes_for(:x, :foo)).to eq({ :foo => 'foo' })
+		      expect(FooBarNode.new(:foo => 'foo', :bar => 'bar').attributes_for(:x, :foo)).to eq({ :foo => 'foo' })
 		    end
 		  end
 
 		  describe '#formatting_options' do
 		    it 'returns an empty hash by default' do
-		      TestNode.new.formatting_options.should be_empty
-		      FooBarNode.new.formatting_options.should be_empty
+		      expect(TestNode.new.formatting_options).to be_empty
+		      expect(FooBarNode.new.formatting_options).to be_empty
 		    end
 
 		    it 'returns an empty hash if there are no formatting attributes' do
-		      TestNode.new(:foo => 'foo', :bar => 'bar').formatting_options.should be_empty
-		      FooBarNode.new(:foo => 'foo', :bar => 'bar').formatting_options.should be_empty
+		      expect(TestNode.new(:foo => 'foo', :bar => 'bar').formatting_options).to be_empty
+		      expect(FooBarNode.new(:foo => 'foo', :bar => 'bar').formatting_options).to be_empty
 		    end
 
 		    it "returns a hash of the node's formatting attributes" do
-		      TestNode.new(:foo => 'foo', :'font-style' => 'italic').formatting_options.should == { :'font-style' => 'italic' }
+		      expect(TestNode.new(:foo => 'foo', :'font-style' => 'italic').formatting_options).to eq({ :'font-style' => 'italic' })
 		    end
 		  end
 
   		describe '#values_at' do
   		  it 'FooBarNode accepts attribute names' do
-  		    FooBarNode.new(:foo => 'Foo', :bar => 'Bar').values_at(:bar, :foo).should == %w{ Bar Foo }
-  		    FooBarNode.new(:foo => 'Foo').values_at(:bar, :foo).should == [nil, 'Foo']
-  		    FooBarNode.new(:foo => 'Foo').values_at(:unknown, :foo).should == [nil, 'Foo']
+  		    expect(FooBarNode.new(:foo => 'Foo', :bar => 'Bar').values_at(:bar, :foo)).to eq(%w{ Bar Foo })
+  		    expect(FooBarNode.new(:foo => 'Foo').values_at(:bar, :foo)).to eq([nil, 'Foo'])
+  		    expect(FooBarNode.new(:foo => 'Foo').values_at(:unknown, :foo)).to eq([nil, 'Foo'])
   		  end
 
   		  it 'TestNode accepts attribute names' do
-  		    TestNode.new(:foo => 'Foo', :bar => 'Bar').values_at(:bar, :foo).should == %w{ Bar Foo }
-  		    TestNode.new(:foo => 'Foo').values_at(:bar, :foo).should == [nil, 'Foo']
-  		    TestNode.new(:foo => 'Foo').values_at(:unknown, :foo).should == [nil, 'Foo']
+  		    expect(TestNode.new(:foo => 'Foo', :bar => 'Bar').values_at(:bar, :foo)).to eq(%w{ Bar Foo })
+  		    expect(TestNode.new(:foo => 'Foo').values_at(:bar, :foo)).to eq([nil, 'Foo'])
+  		    expect(TestNode.new(:foo => 'Foo').values_at(:unknown, :foo)).to eq([nil, 'Foo'])
   		  end
       end
 
       describe '#to_a' do
         it 'returns an empty list by default' do
-          Node.new.attributes.to_a.should == []
+          expect(Node.new.attributes.to_a).to eq([])
         end
 
         it 'TestNode returns an empty list by default' do
-          TestNode.new.attributes.to_a.should == []
+          expect(TestNode.new.attributes.to_a).to eq([])
         end
 
         # it 'TestNode returns a list of all key/value pairs' do
@@ -155,8 +155,8 @@ module CSL
 
       describe 'attributes.keys' do
         it 'returns all attribute names as symbols' do
-          TestNode.new.attributes.keys.should be_empty
-          FooBarNode.new.attributes.keys.should == [:foo, :bar]
+          expect(TestNode.new.attributes.keys).to be_empty
+          expect(FooBarNode.new.attributes.keys).to eq([:foo, :bar])
         end
       end
     end
@@ -164,27 +164,29 @@ module CSL
 
   describe TextNode do
 
-    it { should_not be nil }
-    it { should_not have_children }
-    it { should_not have_attributes }
+    it { is_expected.not_to be nil }
+    it { is_expected.not_to have_children }
+    it { is_expected.not_to have_attributes }
 
     describe '.new' do
       it 'accepts a hash of attributes' do
-        TextNode.new(:foo => 'bar').should have_attributes
+        expect(TextNode.new(:foo => 'bar')).to have_attributes
       end
 
       it 'yields itself to the optional block' do
-        TextNode.new { |n| n.text = 'foo' }.text.should == 'foo'
+        expect(TextNode.new { |n| n.text = 'foo' }.text).to eq('foo')
       end
 
       it 'accepts hash and yields itself to the optional block' do
-        TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.to_xml.should == '<text-node foo="bar">foo</text-node>'
+        expect(TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.to_xml).to eq('<text-node foo="bar">foo</text-node>')
       end
     end
 
     describe '#pretty_print' do
-      TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.pretty_print.should == '<text-node foo="bar">foo</text-node>'
+      it 'prints the text node as XML' do
+        expect(TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.pretty_print).to eq('<text-node foo="bar">foo</text-node>')
+      end
     end
   end
 
-end
+end

data/spec/csl/parser_spec.rb

@@ -6,7 +6,7 @@ module CSL
 
     describe '.instance' do
       it 'returns the parser' do
-        Parser.instance.should be_instance_of(Parser)
+        expect(Parser.instance).to be_instance_of(Parser)
       end
     end
 
@@ -20,38 +20,38 @@ module CSL
             let(:source) { '<foo/>' }
 
             it 'returns a CSL::Node' do
-              Parser.instance.parse(source).should be_a(Node)
+              expect(Parser.instance.parse(source)).to be_a(Node)
             end
 
             it 'returns a node with nodename "foo"' do
-              Parser.instance.parse(source).nodename.should == 'foo'
+              expect(Parser.instance.parse(source).nodename).to eq('foo')
             end
 
             it 'returns a node with no attributes' do
-              Parser.instance.parse(source).should_not have_attributes
+              expect(Parser.instance.parse(source)).not_to have_attributes
             end
 
             it 'returns a node with no children' do
-              Parser.instance.parse(source).should_not have_children
+              expect(Parser.instance.parse(source)).not_to have_children
             end
           end
 
           describe 'for an empty name node' do
             ['<name/>', '<name></name>', '<name> </name>'].each do |source|
               it "returns a Style::Name for #{source.inspect} by default" do
-                Parser.instance.parse!(source).should be_a(Style::Name)
+                expect(Parser.instance.parse!(source)).to be_a(Style::Name)
               end
 
               it "returns a Style::Name for #{source.inspect} for Style scope" do
-                Parser.instance.parse!(source, Style).should be_a(Style::Name)
+                expect(Parser.instance.parse!(source, Style)).to be_a(Style::Name)
               end
 
               it "returns a Node for #{source.inspect} for Locale scope" do
-                Parser.instance.parse!(source, Locale).should be_a(Node)
+                expect(Parser.instance.parse!(source, Locale)).to be_a(Node)
               end
 
               it "returns an Info::Name for #{source.inspect} for Info scope" do
-                Parser.instance.parse!(source, Info).should be_a(Info::Name)
+                expect(Parser.instance.parse!(source, Info)).to be_a(Info::Name)
               end
             end
           end
@@ -60,15 +60,15 @@ module CSL
             let(:source) { '<foo bar="x"/>' }
 
             it 'returns a node with attributes' do
-              Parser.instance.parse(source).should have_attributes
+              expect(Parser.instance.parse(source)).to have_attributes
             end
 
             it 'returns a node with attribute bar' do
-              Parser.instance.parse(source).attribute?(:bar).should be
+              expect(Parser.instance.parse(source).attribute?(:bar)).to be
             end
 
             it 'bar should be "x"' do
-              Parser.instance.parse(source)[:bar].should == 'x'
+              expect(Parser.instance.parse(source)[:bar]).to eq('x')
             end
           end
 
@@ -76,28 +76,28 @@ module CSL
             let(:source) { '<foo>Foo Bar</foo>' }
 
             it 'returns text node' do
-              Parser.instance.parse(source).should be_textnode
+              expect(Parser.instance.parse(source)).to be_textnode
             end
           end
 
           it 'returns a regular node for <x>\n <y/></x>' do
-            Parser.instance.parse("<x>\n <y/></x>").should_not be_textnode
+            expect(Parser.instance.parse("<x>\n <y/></x>")).not_to be_textnode
           end
 
           describe 'xml comments' do
             it 'ignores comment-only documents' do
-              Parser.instance.parse("<!--x></x-->").should be_nil
+              expect(Parser.instance.parse("<!--x></x-->")).to be_nil
             end
 
             it 'ignores comments in normal nodes' do
-              Parser.instance.parse("<x><!-- comment --></x>").should_not have_children
+              expect(Parser.instance.parse("<x><!-- comment --></x>")).not_to have_children
             end
 
             it 'ignores comments in text nodes' do
               node = Parser.instance.parse("<x>foo<!-- comment --></x>")
-              node.should be_textnode
-              node.should_not have_children
-              node.text.should == 'foo'
+              expect(node).to be_textnode
+              expect(node).not_to have_children
+              expect(node.text).to eq('foo')
             end
 
           end

data/spec/csl/schema_spec.rb

@@ -4,104 +4,105 @@ module CSL
   describe 'Schema' do
 
     it 'cannot be instantiated' do
-      Schema.should_not respond_to(:new)
+      expect(Schema).not_to respond_to(:new)
     end
 
     describe '.version' do
       it 'returns a version string' do
-        Schema.version.should match(/^\d+\.\d+\.\d+/)
+        expect(Schema.version).to match(/^\d+\.\d+\.\d+/)
       end
 
       it 'is greater than 1.0' do
-        Schema.version.split(/\./)[0].to_i.should >= 1
+        expect(Schema.version.split(/\./)[0].to_i).to be >= 1
       end
     end
 
     describe '.variables' do
       it 'contains :names fields' do
-        Schema.variables[:names].should_not be_empty
-        Schema.variables[:name].should equal Schema.variables[:names]
+        expect(Schema.variables[:names]).not_to be_empty
+        expect(Schema.variables[:name]).to equal Schema.variables[:names]
       end
 
       it 'contains :date fields' do
-        Schema.variables[:date].should_not be_empty
-        Schema.variables[:dates].should equal Schema.variables[:date]
+        expect(Schema.variables[:date]).not_to be_empty
+        expect(Schema.variables[:dates]).to equal Schema.variables[:date]
       end
 
       it 'contains :text fields' do
-        Schema.variables[:text].should_not be_empty
+        expect(Schema.variables[:text]).not_to be_empty
       end
 
       it 'contains :number fields' do
-        Schema.variables[:numbers].should_not be_empty
-        Schema.variables[:number].should_not be_empty
+        expect(Schema.variables[:numbers]).not_to be_empty
+        expect(Schema.variables[:number]).not_to be_empty
       end
 
       it 'accepts either string or symbol input' do
-        Schema.variables[:names].should equal Schema.variables['names']
+        expect(Schema.variables[:names]).to equal Schema.variables['names']
       end
     end
 
     describe '.types' do
       it 'returns an array' do
-        Schema.types.should be_a(Array)
+        expect(Schema.types).to be_a(Array)
       end
 
       it 'is not empty' do
-        Schema.types.should_not be_empty
+        expect(Schema.types).not_to be_empty
       end
 
       it 'includes :article' do
-        Schema.types.should include(:article)
+        expect(Schema.types).to include(:article)
       end
     end
 
     describe '.categories' do
       it 'given a field name returns the corresponding type' do
-        Schema.categories.values_at(:author, :issued, :abstract, :issue).should ==
+        expect(Schema.categories.values_at(:author, :issued, :abstract, :issue)).to eq(
           [:names, :date, :text, :number]
+        )
       end
 
       it 'accepts either string or symbol input' do
-        Schema.categories.should have_key(:author)
-        Schema.categories['author'].should equal Schema.categories[:author]
+        expect(Schema.categories).to have_key(:author)
+        expect(Schema.categories['author']).to equal Schema.categories[:author]
       end
     end
 
     describe '.validate' do
       it 'accepts and validates a locale instance' do
-        Schema.validate(Locale.load('en-US')).should == []
+        expect(Schema.validate(Locale.load('en-US'))).to eq([])
       end
 
       it 'accepts and validates a locale file path' do
-        Schema.validate(File.join(Locale.root, 'locales-en-US.xml')).should == []
+        expect(Schema.validate(File.join(Locale.root, 'locales-en-US.xml'))).to eq([])
       end
 
       it 'accepts and validates a locale file' do
-        Schema.validate(File.open(File.join(Locale.root, 'locales-en-US.xml'))).should == []
+        expect(Schema.validate(File.open(File.join(Locale.root, 'locales-en-US.xml')))).to eq([])
       end
 
       it 'accepts and validates a locale wildcard path' do
-        Schema.validate(File.join(Locale.root, 'locales-en-*.xml')).should == []
+        expect(Schema.validate(File.join(Locale.root, 'locales-en-*.xml'))).to eq([])
       end
 
       it 'accepts and validates a style file path' do
-        Schema.validate(File.join(Style.root, 'apa.csl')).should == []
+        expect(Schema.validate(File.join(Style.root, 'apa.csl'))).to eq([])
       end
 
       it 'accepts and validates the xml contents of a style instance' do
-        Schema.validate(Style.load(:apa).pretty_print).should == []
+        expect(Schema.validate(Style.load(:apa).pretty_print)).to eq([])
       end
 
       it 'accepts and validates a style instance' do
-        Schema.validate(Style.load(:apa)).should == []
+        expect(Schema.validate(Style.load(:apa))).to eq([])
       end
 
       it 'does not accept invalid xml markup' do
-        Schema.validate(%Q{
+        expect(Schema.validate(%Q{
          <style xmlns="http://purl.org/net/xbiblio/csl" class="note" version="1.0">
          </stle>
-        })[0][0].should == 0 # error on line 0 -> parse error
+        })[0][0]).to eq(0) # error on line 0 -> parse error
       end
 
     # TODO fix nokogiri/jing validation