citeproc 1.0.0.pre12 → 1.0.0

data/spec/citeproc/processor_spec.rb

@@ -2,122 +2,126 @@ require 'spec_helper'
 
 module CiteProc
   describe Processor do
-    before { Class.new(Engine) }
-    
-		let(:p) { Processor.new }
+    let(:p) { Processor.new }
+
     let(:palefire) { Item.new(:id => 'palefire', :type => :book, :title => 'Pale Fire') }
     let(:despair) { Item.new(:id => 'despair', :type => :book, :title => 'Despair') }
-    
+
     it { should_not be nil }
-    
-		describe '#register' do
-			
-			it 'adds the passed-in item to the items hash' do
-				expect { p.register(palefire) }.to change { p.items.length }.by(1)
-			end
-			
-			it 'register the item with its id' do
-				expect { p.register(palefire) }.to change { p.has_key?(:palefire) }
-			end
-			
-		end
-
-		describe '#<<' do
-			
-			it 'registers the passed in item' do
-				expect { p << palefire }.to change { p.has_key?(:palefire) }
-			end
-			
-			it 'returns the processor' do
-				(p << palefire).should be_equal(p)
-			end
-			
-		end
-		
-		describe '#[]' do
-			
-			describe 'when there is no item with the passed-in id' do
-				it 'returns nil' do
-					p[:palefire].should be nil
-				end
-			end
-			
-			describe 'when there is an item with the passed-in id' do
-				before(:each) { p.register(palefire) }
-				
-				it 'returns the item' do
-					p[:palefire].should equal(palefire)
-				end
-			end
-		end
-		
-		describe '#update' do
-			
-			it 'accepts a single item and adds it to the item hash' do
-				expect { p.update(palefire) }.to change { p.items.length }.by(1)
-			end
-			
-			it 'registers the passed-in item with its id' do
-				expect { p.update(palefire) }.to change { p[:palefire] }.from(nil).to(palefire)
-			end
-			
-			describe 'when passed a hash' do
-				it 'registers the value with the key as id' do
-					p.update(:foo => palefire)[:foo].should equal(palefire)
-				end
-				
-				it 'converts the value to an item' do
-					p.update(:foo => { :title => 'The Story of Foo' })[:foo].should be_a(Item)
-				end
-			end
-			
-			it 'adds all items in the array when passed an array' do
-				expect { p.update([palefire, despair]) }.to change { p.items.length }.by(2)
-			end
-
-			it 'adds all items in when passed multiple items' do
-				expect { p.update(palefire, despair) }.to change { p.items.length }.by(2)
-			end
-			
-		end
-		
-		describe '#bibliography (generates the bibliography)' do
-			
-			describe 'when no items have been processed' do
-				
-				it 'returns an empty bibliography'
-				
-				# it 'returns a bibliography of all registered items if invoked with :all'
-				
-			end
-			
-			describe 'when items have been processed' do
-				
-				it 'returns a bibliography containing all cited items'
-
-				# it 'returns a bibliography of all registered items if invoked with :all'
-				
-				describe 'when invoked with a block as filter' do
-				
-					it 'returns an empty bibliography if the block always returns false'
-					
-					it 'returns the full bibliography if the block always returns true'
-					
-					it 'returns a bibliography with all items for which the block returns true'
-					
-				end
-				
-				describe 'when passed a hash as argument' do
-				
-					it 'fails if the hash is no valid selector'
-					
-					it 'creates a selector from the hash and returns a bibliography containing all matching items'
-					
-				end
-				
-			end
-			
-		end
-		
+
+    it { p.engine.should_not be nil }
+    it { p.engine.name.should == 'citeproc-ruby' }
+
+    describe '#register' do
+
+      it 'adds the passed-in item to the items hash' do
+        expect { p.register(palefire) }.to change { p.items.length }.by(1)
+      end
+
+      it 'register the item with its id' do
+        expect { p.register(palefire) }.to change { p.has_key?('palefire') }
+      end
+
+    end
+
+    describe '#<<' do
+
+      it 'registers the passed in item' do
+        expect { p << palefire }.to change { p.has_key?('palefire') }
+      end
+
+      it 'returns the processor' do
+        (p << palefire).should be_equal(p)
+      end
+
+    end
+
+    describe '#[]' do
+
+      describe 'when there is no item with the passed-in id' do
+        it 'returns nil' do
+          p[:palefire].should be nil
+        end
+      end
+
+      describe 'when there is an item with the passed-in id' do
+        before(:each) { p.register(palefire) }
+
+        it 'returns the item' do
+          p[:palefire].should equal(palefire)
+        end
+      end
+    end
+
+    describe '#update' do
+
+      it 'accepts a single item and adds it to the item hash' do
+        expect { p.update(palefire) }.to change { p.items.length }.by(1)
+      end
+
+      it 'registers the passed-in item with its id' do
+        expect { p.update(palefire) }.to change { p[:palefire] }.from(nil).to(palefire)
+      end
+
+      describe 'when passed a hash' do
+        it 'registers the value with the key as id' do
+          p.update(:foo => palefire)[:foo].should equal(palefire)
+        end
+
+        it 'converts the value to an item' do
+          p.update(:foo => { :title => 'The Story of Foo' })[:foo].should be_a(Item)
+        end
+      end
+
+      it 'adds all items in the array when passed an array' do
+        expect { p.update([palefire, despair]) }.to change { p.items.length }.by(2)
+      end
+
+      it 'adds all items in when passed multiple items' do
+        expect { p.update(palefire, despair) }.to change { p.items.length }.by(2)
+      end
+
+    end
+
+    describe '#bibliography (generates the bibliography)' do
+
+      describe 'when no items have been processed' do
+
+        it 'returns an empty bibliography' do
+          p.bibliography.should be_empty
+        end
+
+        # it 'returns a bibliography of all registered items if invoked with :all'
+
+      end
+
+      describe 'when items have been processed' do
+
+        it 'returns a bibliography containing all cited items'
+
+        # it 'returns a bibliography of all registered items if invoked with :all'
+
+        describe 'when invoked with a block as filter' do
+
+          it 'returns an empty bibliography if the block always returns false'
+
+          it 'returns the full bibliography if the block always returns true'
+
+          it 'returns a bibliography with all items for which the block returns true'
+
+        end
+
+        describe 'when passed a hash as argument' do
+
+          it 'fails if the hash is no valid selector'
+
+          it 'creates a selector from the hash and returns a bibliography containing all matching items'
+
+        end
+
+      end
+
+    end
+
   end
-end
+end

data/spec/citeproc/selector_spec.rb

@@ -1,81 +1,90 @@
 require 'spec_helper'
 
 module CiteProc
-	
-	describe Selector do
-		
-		let(:select_books) { Selector.new(:all => { :type => :book }) }
-		
-		it { should_not be nil }
-		it { should be_empty }
-		
-		
-		it 'should have no skip_condtions by default' do
-			Selector.new.skip_conditions.should be_empty
-		end
-
-		it 'should have no condtions by default' do
-			Selector.new.conditions.should 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
-				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
-				end
-			end
-
-			# it 'fails if the hash contains more than two elements'
-			# it 'fails if the hash contains unknown keys'
-			
-			it 'accepts a citeproc json style hash'
-			# it 'accepts a json object (select)' do
-			#         Selector.new(
-			#            "select" => [
-			#               {
-			#                  "field" => "type",
-			#                  "value" => "book"
-			#               },
-			#               {  "field" => "categories",
-			#                   "value" => "1990s"
-			#               }
-			#            ]
-			#         ).conditions.should have(2).items
-			#       end
-      
-		end
-		
-		describe '#to_proc' do
-		end
-		
-		describe '#to_citeproc' do
-			
-			it 'returns nil by default' do
-				Selector.new.to_citeproc.should be nil
-			end
-			
-			it 'converts all matcher to select' do
-				Selector.new(:all => { :a => 'b' }).to_citeproc.should == { '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' }]}
-			end
-
-			it 'converts none matcher to exclude' do
-				Selector.new(:none => { :a => 'b' }).to_citeproc.should == { 'exclude' => [{ 'field' => 'a', 'value' => 'b' }]}
-			end
-
-			
-		end
-		
-	end
-	
-end
+
+  describe Selector do
+
+    let(:select_books) { Selector.new(:all => { :type => :book }) }
+
+    it { should_not be nil }
+    it { should be_empty }
+
+
+    it 'should have no skip_condtions by default' do
+      Selector.new.skip_conditions.should be_empty
+    end
+
+    it 'should have no condtions by default' do
+      Selector.new.conditions.should 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
+        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
+        end
+      end
+
+      # it 'fails if the hash contains more than two elements'
+      # it 'fails if the hash contains unknown keys'
+
+      # it 'accepts a citeproc json style hash'
+
+      it 'accepts a json object (select)' do
+        Selector.new(
+          "select" => [
+            {
+              "field" => "type",
+              "value" => "book"
+            },
+            {  "field" => "categories",
+               "value" => "1990s"
+            }
+          ]
+        ).conditions.should have(2).items
+      end
+    end
+
+    describe '#to_proc' do
+    end
+
+    describe '#to_citeproc' do
+
+      it 'returns nil by default' do
+        Selector.new.to_citeproc.should be nil
+      end
+
+      it 'converts all matcher to select' do
+        Selector.new(:all => { :a => 'b' }).to_citeproc.should == { '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' }]}
+      end
+
+      it 'converts none matcher to exclude' do
+        Selector.new(:none => { :a => 'b' }).to_citeproc.should == { 'exclude' => [{ 'field' => 'a', 'value' => 'b' }]}
+      end
+    end
+
+    describe '#matches?' do
+      it 'always matches by default' do
+        Selector.new.matches?(nil).should be_true
+      end
+    end
+
+    describe '#skip?' do
+      it 'never skips when by default' do
+        Selector.new.skip?(nil).should be_false
+      end
+    end
+  end
+
+end

data/spec/citeproc/variable_spec.rb

@@ -2,22 +2,22 @@ require 'spec_helper'
 
 module CiteProc
   describe Variable do
-    
+
     describe '.new' do
       it { should be_an_instance_of(Variable) }
-      
+
       it 'is empty by default' do
         Variable.new.should be_empty
       end
-      
+
       it 'equals an empty string (==) by default' do
         Variable.new.should == ''
       end
-      
+
       it 'matches an empty pattern by default' do
         Variable.new.should =~ /^$/
       end
-      
+
       it 'accepts a string value' do
         Variable.new('test').should == 'test'
       end
@@ -25,10 +25,10 @@ module CiteProc
       it 'accepts a numeric value' do
         Variable.new(23).should == '23'
       end
-      
+
       it 'accepts a floating point value' do
         Variable.new(23.12).should == '23.12'
-      end      
+      end
     end
 
     describe '.fields' do
@@ -50,41 +50,41 @@ module CiteProc
         Variable.fields[:numbers].should_not be_empty
         Variable.fields[:number].should_not be_empty
       end
-      
+
       it 'accepts either string or symbol input' do
         Variable.fields[:names].should equal Variable.fields['names']
-      end  
+      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]
       end
-      
+
       it 'accepts either string or symbol input' do
         Variable.types.should have_key(:author)
         Variable.types['author'].should equal Variable.types[:author]
       end
     end
-    
+
     describe '#to_s' do
       it 'displays the value' do
         Variable.new('test').to_s.should == 'test'
       end
     end
-    
+
     describe '#to_i' do
       it 'returns zero by default' do
         Variable.new.to_i.should == 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)
           end
         end
-        
+
         it 'returns only the first numeric value if there are several' do
           Variable.new('testing 1, 2, 3...').to_i.should == 1
         end
@@ -95,24 +95,24 @@ module CiteProc
       it 'returns zero by default' do
         Variable.new.to_f.should == 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
           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
         end
-        
+
         it 'works with dot and comma separators' do
           Variable.new('1,23').to_f.should == Variable.new('1.23').to_f
         end
       end
     end
-    
+
     describe '#numeric?' do
       it 'returns false by default' do
         Variable.new.should_not be_numeric
@@ -127,28 +127,28 @@ module CiteProc
         it 'returns true (integer initialized)' do
           Variable.new(23).should be_numeric
         end
-      end 
+      end
 
       context 'variable does not contain a number' do
         it 'returns false for strings' do
           Variable.new('test').should_not 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
         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
         end
-        
+
         it 'returns true for simple lists' do
           Variable.new('23,24').should be_numeric
           Variable.new('23 , 24').should be_numeric
@@ -156,14 +156,14 @@ module CiteProc
           Variable.new('23 ,24').should be_numeric
           Variable.new('23 ,24,25 , 26, 27').should 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
         end
       end
     end
-    
+
     describe '#strip_markup' do
       let(:greeting) { '<h1>hello<b> world</b></h1>' }
       it 'returns a string stripped of html tags' do
@@ -184,13 +184,13 @@ module CiteProc
         v.should == 'hello world'
       end
     end
-    
-    
+
+
     describe 'sorting' do
     end
-    
+
     describe '#to_json' do
     end
-    
+
   end
-end
+end