citeproc 1.0.1 → 1.0.2

data/spec/citeproc/processor_spec.rb

@@ -9,8 +9,8 @@ module CiteProc
 
     it { should_not be nil }
 
-    it { p.engine.should_not be nil }
-    it { p.engine.name.should == 'citeproc-ruby' }
+    it { expect(p.engine).not_to be nil }
+    it { expect(p.engine.name).to eq('citeproc-ruby') }
 
     describe '#register' do
 
@@ -31,7 +31,7 @@ module CiteProc
       end
 
       it 'returns the processor' do
-        (p << palefire).should be_equal(p)
+        expect(p << palefire).to be_equal(p)
       end
 
     end
@@ -40,7 +40,7 @@ module CiteProc
 
       describe 'when there is no item with the passed-in id' do
         it 'returns nil' do
-          p[:palefire].should be nil
+          expect(p[:palefire]).to be nil
         end
       end
 
@@ -48,7 +48,7 @@ module CiteProc
         before(:each) { p.register(palefire) }
 
         it 'returns the item' do
-          p[:palefire].should equal(palefire)
+          expect(p[:palefire]).to equal(palefire)
         end
       end
     end
@@ -65,11 +65,11 @@ module CiteProc
 
       describe 'when passed a hash' do
         it 'registers the value with the key as id' do
-          p.update(:foo => palefire)[:foo].should equal(palefire)
+          expect(p.update(:foo => palefire)[:foo]).to equal(palefire)
         end
 
         it 'converts the value to an item' do
-          p.update(:foo => { :title => 'The Story of Foo' })[:foo].should be_a(Item)
+          expect(p.update(:foo => { :title => 'The Story of Foo' })[:foo]).to be_a(Item)
         end
       end
 
@@ -88,7 +88,7 @@ module CiteProc
       describe 'when no items have been processed' do
 
         it 'returns an empty bibliography' do
-          p.bibliography.should be_empty
+          expect(p.bibliography).to be_empty
         end
 
         # it 'returns a bibliography of all registered items if invoked with :all'

data/spec/citeproc/selector_spec.rb

@@ -11,24 +11,24 @@ module CiteProc
 
 
     it 'should have no skip_condtions by default' do
-      Selector.new.skip_conditions.should be_empty
+      expect(Selector.new.skip_conditions).to be_empty
     end
 
     it 'should have no condtions by default' do
-      Selector.new.conditions.should be_empty
+      expect(Selector.new.conditions).to be_empty
     end
 
     describe 'constructing' do
 
       %w{ all none any skip }.each do |matcher|
         it "accepts the ruby style matcher '#{matcher}'" do
-          Selector.new(matcher => {}).should_not be nil
+          expect(Selector.new(matcher => {})).not_to be nil
         end
       end
 
       %w{ include exclude select quash }.each do |matcher|
         it "accepts the citeproc-js style matcher '#{matcher}'" do
-          Selector.new(matcher => {}).should_not be nil
+          expect(Selector.new(matcher => {})).not_to be nil
         end
       end
 
@@ -38,7 +38,7 @@ module CiteProc
       # it 'accepts a citeproc json style hash'
 
       it 'accepts a json object (select)' do
-        Selector.new(
+        expect(Selector.new(
           "select" => [
             {
               "field" => "type",
@@ -48,7 +48,7 @@ module CiteProc
                "value" => "1990s"
             }
           ]
-        ).conditions.should have(2).items
+        ).conditions.size).to eq(2)
       end
     end
 
@@ -58,31 +58,31 @@ module CiteProc
     describe '#to_citeproc' do
 
       it 'returns nil by default' do
-        Selector.new.to_citeproc.should be nil
+        expect(Selector.new.to_citeproc).to be nil
       end
 
       it 'converts all matcher to select' do
-        Selector.new(:all => { :a => 'b' }).to_citeproc.should == { 'select' => [{ 'field' => 'a', 'value' => 'b' }]}
+        expect(Selector.new(:all => { :a => 'b' }).to_citeproc).to eq({ 'select' => [{ 'field' => 'a', 'value' => 'b' }]})
       end
 
       it 'converts any matcher to include' do
-        Selector.new(:any => { :a => 'b' }).to_citeproc.should == { 'include' => [{ 'field' => 'a', 'value' => 'b' }]}
+        expect(Selector.new(:any => { :a => 'b' }).to_citeproc).to eq({ 'include' => [{ 'field' => 'a', 'value' => 'b' }]})
       end
 
       it 'converts none matcher to exclude' do
-        Selector.new(:none => { :a => 'b' }).to_citeproc.should == { 'exclude' => [{ 'field' => 'a', 'value' => 'b' }]}
+        expect(Selector.new(:none => { :a => 'b' }).to_citeproc).to eq({ 'exclude' => [{ 'field' => 'a', 'value' => 'b' }]})
       end
     end
 
     describe '#matches?' do
       it 'always matches by default' do
-        Selector.new.matches?(nil).should be_true
+        expect(Selector.new.matches?(nil)).to be_true
       end
     end
 
     describe '#skip?' do
       it 'never skips when by default' do
-        Selector.new.skip?(nil).should be_false
+        expect(Selector.new.skip?(nil)).to be_false
       end
     end
   end

data/spec/citeproc/utilities_spec.rb

@@ -4,7 +4,7 @@ describe 'CiteProc' do
 
   describe '.process' do
     it 'is defined' do
-      CiteProc.should respond_to(:process)
+      expect(CiteProc).to respond_to(:process)
     end
   end
 

data/spec/citeproc/variable_spec.rb

@@ -7,159 +7,159 @@ module CiteProc
       it { should be_an_instance_of(Variable) }
 
       it 'is empty by default' do
-        Variable.new.should be_empty
+        expect(Variable.new).to be_empty
       end
 
       it 'equals an empty string (==) by default' do
-        Variable.new.should == ''
+        expect(Variable.new).to eq('')
       end
 
       it 'matches an empty pattern by default' do
-        Variable.new.should =~ /^$/
+        expect(Variable.new).to match(/^$/)
       end
 
       it 'accepts a string value' do
-        Variable.new('test').should == 'test'
+        expect(Variable.new('test')).to eq('test')
       end
 
       it 'accepts a numeric value' do
-        Variable.new(23).should == '23'
+        expect(Variable.new(23)).to eq('23')
       end
 
       it 'accepts a floating point value' do
-        Variable.new(23.12).should == '23.12'
+        expect(Variable.new(23.12)).to eq('23.12')
       end
     end
 
     describe '.fields' do
       it 'contains :names fields' do
-        Variable.fields[:names].should_not be_empty
-        Variable.fields[:name].should equal Variable.fields[:names]
+        expect(Variable.fields[:names]).not_to be_empty
+        expect(Variable.fields[:name]).to equal Variable.fields[:names]
       end
 
       it 'contains :date fields' do
-        Variable.fields[:date].should_not be_empty
-        Variable.fields[:dates].should equal Variable.fields[:date]
+        expect(Variable.fields[:date]).not_to be_empty
+        expect(Variable.fields[:dates]).to equal Variable.fields[:date]
       end
 
       it 'contains :text fields' do
-        Variable.fields[:text].should_not be_empty
+        expect(Variable.fields[:text]).not_to be_empty
       end
 
       it 'contains :number fields' do
-        Variable.fields[:numbers].should_not be_empty
-        Variable.fields[:number].should_not be_empty
+        expect(Variable.fields[:numbers]).not_to be_empty
+        expect(Variable.fields[:number]).not_to be_empty
       end
 
       it 'accepts either string or symbol input' do
-        Variable.fields[:names].should equal Variable.fields['names']
+        expect(Variable.fields[:names]).to equal Variable.fields['names']
       end
     end
 
     describe '.types' do
       it 'given a field name returns the corresponding type' do
-        Variable.types.values_at(:author, :issued, :abstract, :issue).should == [:names, :date, :text, :number]
+        expect(Variable.types.values_at(:author, :issued, :abstract, :issue)).to eq([:names, :date, :text, :number])
       end
 
       it 'accepts either string or symbol input' do
-        Variable.types.should have_key(:author)
-        Variable.types['author'].should equal Variable.types[:author]
+        expect(Variable.types).to have_key(:author)
+        expect(Variable.types['author']).to equal Variable.types[:author]
       end
     end
 
     describe '#to_s' do
       it 'displays the value' do
-        Variable.new('test').to_s.should == 'test'
+        expect(Variable.new('test').to_s).to eq('test')
       end
     end
 
     describe '#to_i' do
       it 'returns zero by default' do
-        Variable.new.to_i.should == 0
+        expect(Variable.new.to_i).to eq(0)
       end
 
       context 'when the value is numeric' do
         %w{ -23 -1 0 1 23 }.each do |value|
           it "returns the integer value (#{value})" do
-            Variable.new(value).to_i.should equal(value.to_i)
+            expect(Variable.new(value).to_i).to equal(value.to_i)
           end
         end
 
         it 'returns only the first numeric value if there are several' do
-          Variable.new('testing 1, 2, 3...').to_i.should == 1
+          expect(Variable.new('testing 1, 2, 3...').to_i).to eq(1)
         end
       end
     end
 
     describe '#to_f' do
       it 'returns zero by default' do
-        Variable.new.to_f.should == 0.0
+        expect(Variable.new.to_f).to eq(0.0)
       end
 
       context 'when the value is numeric' do
         %w{ -23.2 -1.45 0.2 1.733 23 }.each do |value|
           it "returns the integer value (#{value})" do
-            Variable.new(value).to_f.should == value.to_f
+            expect(Variable.new(value).to_f).to eq(value.to_f)
           end
         end
 
         it 'returns only the first numeric value if there are several' do
-          Variable.new('testing 1, 2, 3...').to_f.should == 1.0
+          expect(Variable.new('testing 1, 2, 3...').to_f).to eq(1.0)
         end
 
         it 'works with dot and comma separators' do
-          Variable.new('1,23').to_f.should == Variable.new('1.23').to_f
+          expect(Variable.new('1,23').to_f).to eq(Variable.new('1.23').to_f)
         end
       end
     end
 
     describe '#numeric?' do
       it 'returns false by default' do
-        Variable.new.should_not be_numeric
+        expect(Variable.new).not_to be_numeric
       end
 
       context 'variable contains a number' do
         it 'returns true (string initialized)' do
-          Variable.new('23').should be_numeric
-          Variable.new('X23').should be_numeric
-          Variable.new('23rd').should be_numeric
+          expect(Variable.new('23')).to be_numeric
+          expect(Variable.new('X23')).to be_numeric
+          expect(Variable.new('23rd')).to be_numeric
         end
         it 'returns true (integer initialized)' do
-          Variable.new(23).should be_numeric
+          expect(Variable.new(23)).to be_numeric
         end
       end
 
       context 'variable does not contain a number' do
         it 'returns false for strings' do
-          Variable.new('test').should_not be_numeric
+          expect(Variable.new('test')).not_to be_numeric
         end
       end
 
       context 'variable contains numbers but is not numeric' do
         it 'returns false for strings' do
-          Variable.new('23rd test').should_not be_numeric
-          Variable.new('23rd, 24th & 25th edition').should_not be_numeric
+          expect(Variable.new('23rd test')).not_to be_numeric
+          expect(Variable.new('23rd, 24th & 25th edition')).not_to be_numeric
         end
       end
 
       context 'variable contains multiple numbers' do
         it 'returns true for simple ranges' do
-          Variable.new('23-24').should be_numeric
-          Variable.new('23 - 24').should be_numeric
-          Variable.new('23-  24').should be_numeric
+          expect(Variable.new('23-24')).to be_numeric
+          expect(Variable.new('23 - 24')).to be_numeric
+          expect(Variable.new('23-  24')).to be_numeric
         end
 
         it 'returns true for simple lists' do
-          Variable.new('23,24').should be_numeric
-          Variable.new('23 , 24').should be_numeric
-          Variable.new('23,  24').should be_numeric
-          Variable.new('23 ,24').should be_numeric
-          Variable.new('23 ,24,25 , 26, 27').should be_numeric
+          expect(Variable.new('23,24')).to be_numeric
+          expect(Variable.new('23 , 24')).to be_numeric
+          expect(Variable.new('23,  24')).to be_numeric
+          expect(Variable.new('23 ,24')).to be_numeric
+          expect(Variable.new('23 ,24,25 , 26, 27')).to be_numeric
         end
 
         it 'returns true for complex lists' do
-          Variable.new('23rd, 24th & 25th').should be_numeric
-          Variable.new('X23, A2-49th & 25th & A1, B2').should be_numeric
+          expect(Variable.new('23rd, 24th & 25th')).to be_numeric
+          expect(Variable.new('X23, A2-49th & 25th & A1, B2')).to be_numeric
         end
       end
     end
@@ -167,12 +167,12 @@ module CiteProc
     describe '#strip_markup' do
       let(:greeting) { '<h1>hello<b> world</b></h1>' }
       it 'returns a string stripped of html tags' do
-        Variable.new(greeting).strip_markup.should == 'hello world'
+        expect(Variable.new(greeting).strip_markup).to eq('hello world')
       end
       it 'does not alter the value itself' do
         v = Variable.new(greeting)
         v.strip_markup
-        v.should == greeting
+        expect(v).to eq(greeting)
       end
     end
 
@@ -181,7 +181,7 @@ module CiteProc
       it 'strips of html tags' do
         v = Variable.new(greeting)
         v.strip_markup!
-        v.should == 'hello world'
+        expect(v).to eq('hello world')
       end
     end
 

data/spec/spec_helper.rb

@@ -12,14 +12,15 @@ begin
     # Debugger.start
   when defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
     require 'rubinius/debugger'
-  else
+  when RUBY_VERSION < '2.0'
     require 'debugger'
+  else
+    require 'byebug'
   end
 rescue LoadError
   # ignore
 end
 
-
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $:.unshift(File.dirname(__FILE__))
 

data/tasks/testsuite.rb

@@ -9,9 +9,6 @@ module CSL
       quotes_PunctuationWithInnerQuote            # replaces single quotes and apostrophes
       sort_SubstituteTitle                        # ---
       substitute_SuppressOrdinaryVariable         # citeproc-js bug?
-      sort_VariousNameMacros1                     # ---
-      sort_VariousNameMacros2                     # ---
-      sort_VariousNameMacros3                     # ---
       sort_FamilyOnly                             # invalid CSL (no layout) / ANZ after Aardvark?
       name_ParticleCaps3                          # " in family name
       testers_SecondAutoGeneratedZoteroPluginTest # uses <sc> for small-caps

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: citeproc
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Sylvester Keil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-10 00:00:00.000000000 Z
+date: 2015-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: namae
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
 description: "\n    A cite processor interface for Citation Style Language (CSL) styles.\n
@@ -32,10 +32,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .document
-- .rspec
-- .simplecov
-- .yardopts
+- ".document"
+- ".rspec"
+- ".simplecov"
+- ".yardopts"
 - AGPL
 - BSDL
 - Gemfile
@@ -91,17 +91,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 cite processor interface.