csl 1.2.3 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2440f83717e0f6837afcc83266cd4a3840a3616
-  data.tar.gz: 8b23cc4a6b0d37be88b2ab89db161a1a807e6ffa
+  metadata.gz: f0c6bac5a4e0a88bd83e78fc8acac300a9d8a122
+  data.tar.gz: 6cae82297a9550d275d92c8f1b86ca34b67fe181
 SHA512:
-  metadata.gz: 4b4b1ba0f7ca04742e7366595629000cb1bf40ca526a3fee6d637beb91632794b9cb63e39fbaad6b41813daa71a3a394fd3c25e770200eef5081dc3d8d839ba6
-  data.tar.gz: dfed6689b3b10f021634deb117dd81f740f8ebf9a4c87f3e1b0552b28a41dd1eb2055a59f1f44d6abecc383d3b124d86f10f019b2ed6b0b35bf392d5d49b23fa
+  metadata.gz: 27597362d702c9ff06902e59386ed237050f63aa238c336318cfc9012e7576d7e0299b6e053cbd35861799e734338e1a69eb38113149578c2f65e42999e5a2a1
+  data.tar.gz: 42e659e3de7d61a556317178a031a0cd5b0305aa8c6c804627d40a5a4e2ecf6551f69dabdb3a3413276f649e7d7058ba5dba509a531d6fa34b7aa526aeb031fa

data/.rspec

@@ -1,3 +1,3 @@
 --color
 --format progress
---require spec_helper.rb 
+--require spec_helper.rb

data/Gemfile

@@ -3,7 +3,7 @@ gemspec
 
 group :development, :test do
   gem 'rake', '~>10.0'
-  gem 'rspec', '~>2.13'
+  gem 'rspec', '~>3.0'
   gem 'cucumber', '~>1.2'
   gem 'simplecov', '~>0.8', :require => false
   gem 'rubinius-coverage', :platform => :rbx
@@ -11,8 +11,14 @@ group :development, :test do
 end
 
 group :debug do
-  gem 'ruby-debug', :require => false, :platforms => [:jruby]
-  gem 'debugger', :require => false, :platforms => [:mri]
+  if RUBY_VERSION >= '2.0'
+    gem 'byebug', :require => false, :platforms => :mri
+  else
+    gem 'debugger', :require => false, :platforms => :mri
+  end
+
+  gem 'ruby-debug', :require => false, :platforms => :jruby
+
   gem 'rubinius-debugger', :require => false, :platforms => :rbx
   gem 'rubinius-compiler', :require => false, :platforms => :rbx
 end
@@ -24,14 +30,13 @@ end
 group :extra do
   gem 'guard', '~>2.2'
   gem 'guard-rspec'
+  gem 'guard-cucumber'
   gem 'bond'
   gem 'diff-lcs'
   gem 'pry'
-  gem 'guard-cucumber'
-  gem 'rb-fsevent', '~>0.9', :platforms => [:ruby]
-
-  gem 'yard', '~>0.8', :platforms => [:mri]
-  gem 'redcarpet', '~>3.0', :platforms => [:mri]
+  gem 'rb-fsevent', '~>0.9', :platforms => :ruby
+  gem 'yard', '~>0.8', :platforms => :mri
+  gem 'redcarpet', '~>3.0', :platforms => :mri
 end
 
 group :rbx do

data/Guardfile

@@ -1,7 +1,4 @@
-# A sample Guardfile
-# More info at https://github.com/guard/guard#readme
-
-guard 'rspec' do
+guard 'rspec', :cmd => 'bundle exec rspec' do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { 'spec' }
@@ -9,6 +6,10 @@ end
 
 guard 'cucumber' do
   watch(%r{^features/.+\.feature$})
-  watch(%r{^features/support/.+$})          { 'features' }
-  watch(%r{^features/step_definitions/(.+)_steps\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'features' }
+  watch(%r{^features/support/.+$}) { 'features' }
+  watch(%r{^features/step_definitions/(.+)_steps\.rb$}) { |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || 'features'
+  }
 end
+
+# vim: syntax=ruby

data/features/support/env.rb

@@ -12,8 +12,10 @@ begin
     Debugger.start
   when defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
     require 'rubinius/debugger'
-  else
+  when defined?(RUBY_VERSION) && RUBY_VERSION < '2.0'
     require 'debugger'
+  else
+    require 'byebug'
   end
 rescue LoadError
   # ignore

data/lib/csl/node.rb

@@ -475,9 +475,10 @@ module CSL
     end
 
     def <=>(other)
+      return nil unless other.is_a?(Node)
+      return 1 if other.textnode?
+
       [nodename, attributes, children] <=> [other.nodename, other.attributes, other.children]
-    rescue
-      nil
     end
 
     # Returns the node' XML tags (including attribute assignments) as an
@@ -603,6 +604,13 @@ module CSL
       ["<#{attribute_assignments.unshift(nodename).join(' ')}>#{to_s}</#{nodename}>"]
     end
 
+    def <=>(other)
+      return nil unless other.is_a?(Node)
+      return -1 unless other.textnode?
+
+      [nodename, attributes, text] <=> [other.nodename, other.attributes, other.text]
+    end
+
     def inspect
       "#<#{[self.class.name, text.inspect, *attribute_assignments].join(' ')}>"
     end

data/lib/csl/version.rb

@@ -1,3 +1,3 @@
 module CSL
-  VERSION = '1.2.3'.freeze
+  VERSION = '1.3.0'.freeze
 end

data/spec/csl/node_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 module CSL
 
-	describe Node do
+  describe Node do
 
     it { is_expected.not_to be nil }
     it { is_expected.not_to have_children }
-    it { is_expected.not_to have_attributes }
+    it { is_expected.to have_attributes(:attributes => {}) }
 
-		describe 'given a FooBarNode with attributes :foo and :bar and a TestNode without defined attributes' do
+    describe 'given a FooBarNode with attributes :foo and :bar and a TestNode without defined attributes' do
       before(:all) do
         class FooBarNode < Node
           attr_struct :foo, :bar
@@ -25,110 +25,121 @@ module CSL
         expect(TestNode.const_defined?(:Attributes)).not_to be_truthy
       end
 
-		  it 'TestNode attributes are a regular Hash' do
-		    expect(TestNode.new.attributes).to be_a(Hash)
-		  end
+      it 'TestNode attributes are a regular Hash' do
+        expect(TestNode.new.attributes).to be_a(Hash)
+      end
 
-		  it 'FooBarNode attributes are a Struct' do
-		    expect(FooBarNode.new.attributes).to be_a(Struct)
-		  end
+      it 'FooBarNode attributes are a Struct' do
+        expect(FooBarNode.new.attributes).to be_a(Struct)
+      end
 
-		  describe '#match?' do
-		    it 'matches an empty query' do
-		      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
+      describe '#match?' do
+        it 'matches an empty query' do
+          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
-		      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
+          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
-		      expect(FooBarNode.new.match?(:foo => 'bar')).to be_falsey
-		      expect(FooBarNode.new(:foo => 'f').match?(:foo => 'f', :bar => 'b')).to be_falsey
+          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
-		      expect(FooBarNode.new(:foo => 'f').match?(:foo => 'f', :unknown => 'u')).to be_falsey
+          expect(FooBarNode.new(:foo => 'f').match?(:foo => 'f', :unknown => 'u')).to be_falsey
         end
 
         it 'matches irrespective of order' do
-		      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
-		      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
-		      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
-		      expect(TestNode.new.attributes_for).to be_empty
-		      expect(TestNode.new.attributes_for(:x, :y)).to 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
-		      expect(TestNode.new(:foo => 'foo').attributes_for).to be_empty
-		      expect(TestNode.new(:foo => 'foo').attributes_for(:x, :y)).to 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
-		      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
-		      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
-		      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
-		      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
-  		    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
-  		    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
+          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
+          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
+          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
+          expect(TestNode.new.attributes_for).to be_empty
+          expect(TestNode.new.attributes_for(:x, :y)).to 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
+          expect(TestNode.new(:foo => 'foo').attributes_for).to be_empty
+          expect(TestNode.new(:foo => 'foo').attributes_for(:x, :y)).to 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
+          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
+          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
+          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
+          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
+          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
+          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
@@ -160,17 +171,54 @@ module CSL
         end
       end
     end
-	end
+
+    describe 'comparing nodes' do
+      it 'empty nodes are equal' do
+        expect(Node.new).to eq(Node.new)
+      end
+
+      it 'considers node names' do
+        expect(Node.new).not_to eq(Node.new { |n| n.nodename = 'foo' })
+      end
+
+      it 'considers attributes' do
+        expect(Node.new(:foo => 'bar')).to eq(Node.new(:foo => 'bar'))
+        expect(Node.new(:foo => 'bar')).not_to eq(Node.new(:foo => 'baz'))
+
+        expect(Node.new(:foo => 'bar', :baz => 'qux'))
+          .not_to eq(Node.new(:foo => 'bar'))
+
+        expect(Node.new(:foo => 'bar', :baz => 'qux'))
+          .to eq(Node.new(:baz => 'qux', :foo => 'bar'))
+      end
+
+      it 'considers children' do
+        n1, n2 = Node.new, Node.new
+
+        n1 << Node.new
+        expect(n1).not_to eq(n2)
+
+        n2 << Node.new
+        expect(n1).to eq(n2)
+
+        n2.children[0][:foo] = 'bar'
+        expect(n1).not_to eq(n2)
+
+        n1.children[0][:foo] = 'bar'
+        expect(n1).to eq(n2)
+      end
+    end
+  end
 
   describe TextNode do
 
     it { is_expected.not_to be nil }
     it { is_expected.not_to have_children }
-    it { is_expected.not_to have_attributes }
+    it { is_expected.to have_attributes(:attributes => {}) }
 
     describe '.new' do
       it 'accepts a hash of attributes' do
-        expect(TextNode.new(:foo => 'bar')).to have_attributes
+        expect(TextNode.new(:foo => 'bar').attributes).to have_key(:foo)
       end
 
       it 'yields itself to the optional block' do
@@ -178,13 +226,51 @@ module CSL
       end
 
       it 'accepts hash and yields itself to the optional block' do
-        expect(TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.to_xml).to eq('<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
       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>')
+        expect(TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.pretty_print)
+          .to eq('<text-node foo="bar">foo</text-node>')
+      end
+    end
+
+    describe 'comparing nodes' do
+      it 'empty nodes are equal' do
+        expect(TextNode.new).to eq(TextNode.new)
+      end
+
+      it 'considers node names' do
+        expect(TextNode.new).not_to eq(TextNode.new { |n| n.nodename = 'foo' })
+      end
+
+      it 'considers attributes' do
+        expect(TextNode.new(:foo => 'bar')).to eq(TextNode.new(:foo => 'bar'))
+        expect(TextNode.new(:foo => 'bar')).not_to eq(TextNode.new(:foo => 'baz'))
+
+        expect(TextNode.new(:foo => 'bar', :baz => 'qux'))
+          .not_to eq(TextNode.new(:foo => 'bar'))
+
+        expect(TextNode.new(:foo => 'bar', :baz => 'qux'))
+          .to eq(TextNode.new(:baz => 'qux', :foo => 'bar'))
+      end
+
+      it 'considers text' do
+        n1, n2 = TextNode.new, TextNode.new
+
+        n1.text = 'foo'
+        expect(n1).not_to eq(n2)
+
+        n2.text = 'foo'
+        expect(n1).to eq(n2)
+      end
+
+      it 'text nodes are less than other nodes' do
+        expect(TextNode.new).to be < Node.new
+        expect(Node.new).not_to be < TextNode.new
       end
     end
   end

data/spec/csl/parser_spec.rb

@@ -28,7 +28,7 @@ module CSL
             end
 
             it 'returns a node with no attributes' do
-              expect(Parser.instance.parse(source)).not_to have_attributes
+              expect(Parser.instance.parse(source).attributes).to be_empty
             end
 
             it 'returns a node with no children' do
@@ -57,26 +57,26 @@ module CSL
           end
 
           describe 'for <foo bar="x"/>' do
-            let(:source) { '<foo bar="x"/>' }
+            let(:src) { '<foo bar="x"/>' }
 
             it 'returns a node with attributes' do
-              expect(Parser.instance.parse(source)).to have_attributes
+              expect(Parser.instance.parse(src).attributes).not_to be_empty
             end
 
             it 'returns a node with attribute bar' do
-              expect(Parser.instance.parse(source).attribute?(:bar)).to be
+              expect(Parser.instance.parse(src).attribute?(:bar)).to be
             end
 
             it 'bar should be "x"' do
-              expect(Parser.instance.parse(source)[:bar]).to eq('x')
+              expect(Parser.instance.parse(src)[:bar]).to eq('x')
             end
           end
 
           describe 'for <foo>Foo Bar</foo>' do
-            let(:source) { '<foo>Foo Bar</foo>' }
+            let(:src) { '<foo>Foo Bar</foo>' }
 
             it 'returns text node' do
-              expect(Parser.instance.parse(source)).to be_textnode
+              expect(Parser.instance.parse(src)).to be_textnode
             end
           end
 

data/spec/csl/style/number_spec.rb

@@ -2,26 +2,26 @@ require 'spec_helper'
 
 module CSL
   describe Style::Number do
-  
+
     describe '.new' do
       it 'returns an empty number tag by default' do
-        expect(Style::Number.new).not_to have_attributes
+        expect(Style::Number.new.attributes).to be_empty
       end
-      
+
       it 'accepts a form attribute' do
         expect(Style::Number.new(:form => 'roman')).to be_roman
       end
     end
-    
+
     describe '#numeric?' do
       it 'returns true by default' do
         expect(Style::Number.new).to be_numeric
       end
-      
+
       it 'returns false if the form attribute is set to a value other than :numeric' do
         expect(Style::Number.new(:form => 'foo')).not_to be_numeric
       end
-      
+
       it 'returns false if the form attribute is set to :numeric' do
         expect(Style::Number.new(:form => 'numeric')).to be_numeric
       end
@@ -31,11 +31,11 @@ module CSL
       it 'returns false by default' do
         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
         expect(Style::Number.new(:form => 'ordinal')).not_to be_roman
       end
-      
+
       it 'returns false if the form attribute is set to :roman' do
         expect(Style::Number.new(:form => 'roman')).to be_roman
       end
@@ -45,11 +45,11 @@ module CSL
       it 'returns false by default' do
         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
         expect(Style::Number.new(:form => 'long-ordinal')).not_to be_ordinal
       end
-      
+
       it 'returns false if the form attribute is set to :ordinal' do
         expect(Style::Number.new(:form => 'ordinal')).to be_ordinal
         expect(Style::Number.new(:form => :ordinal)).to be_ordinal
@@ -60,26 +60,26 @@ module CSL
       it 'returns false by default' do
         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
         expect(Style::Number.new(:form => 'ordinal')).not_to be_long_ordinal
       end
-      
+
       it 'returns false if the form attribute is set to :ordinal' do
         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
         expect(Style::Number.new.to_xml).to eq('<number/>')
       end
-      
+
       it 'returns a tag with a all attribute assignments' do
         expect(Style::Number.new(:form => 'roman').to_xml).to eq('<number form="roman"/>')
       end
     end
-    
+
   end
-end
+end

data/spec/spec_helper.rb

@@ -12,8 +12,10 @@ begin
     Debugger.start
   when defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
     require 'rubinius/debugger'
-  else
+  when defined?(RUBY_VERSION) && RUBY_VERSION < '2.0'
     require 'debugger'
+  else
+    require 'byebug'
   end
 rescue LoadError
   # ignore

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: csl
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.0
 platform: ruby
 authors:
 - Sylvester Keil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-07 00:00:00.000000000 Z
+date: 2015-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: namae
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
 description: "\n\t\tA Ruby parser and full API for the Citation Style Language (CSL),\n\t\tan
@@ -32,11 +32,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .document
-- .gitignore
-- .rspec
-- .simplecov
-- .yardopts
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".simplecov"
+- ".yardopts"
 - AGPL
 - BSDL
 - Gemfile
@@ -129,17 +129,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A Ruby CSL parser and library