csl 1.0.0.pre1

data/spec/csl/parser_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+module CSL
+  
+  describe Parser do
+
+    describe '.instance' do
+      it 'returns the parser' do
+        Parser.instance.should be_instance_of(Parser)
+      end
+    end
+
+    Parser.engines.each_pair do |name, parser|
+      describe "when using the #{name} parser " do
+        before(:all) { Parser.instance.parser = parser }
+    
+        describe '#parse' do
+
+          describe 'for <foo/>' do
+            let(:source) { '<foo/>' }
+
+            it 'returns a CSL::Node' do
+              Parser.instance.parse(source).should be_a(Node)
+            end
+
+            it 'returns a node with nodename "foo"' do
+              Parser.instance.parse(source).nodename.should == 'foo'
+            end
+
+            it 'returns a node with no attributes' do
+              Parser.instance.parse(source).should_not have_attributes
+            end
+
+            it 'returns a node with no children' do
+              Parser.instance.parse(source).should_not have_children
+            end
+          end
+
+          describe 'for <foo bar="x"/>' do
+            let(:source) { '<foo bar="x"/>' }
+            
+            it 'returns a node with attributes' do
+              Parser.instance.parse(source).should have_attributes
+            end
+
+            it 'returns a node with attribute bar' do
+              Parser.instance.parse(source).attribute?(:bar).should be
+            end
+
+            it 'bar should be "x"' do
+              Parser.instance.parse(source)[:bar].should == 'x'
+            end
+          end
+
+          describe 'for <foo>Foo Bar</foo>' do
+            let(:source) { '<foo>Foo Bar</foo>' }
+            
+            it 'returns text node' do
+              Parser.instance.parse(source).should 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
+          end
+          
+					describe 'xml comments' do
+						it 'ignores comment-only documents' do
+							Parser.instance.parse("<!--x></x-->").should be_nil
+						end
+
+						it 'ignores comments in normal nodes' do
+							Parser.instance.parse("<x><!-- comment --></x>").should_not 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'
+						end
+						
+					end
+					
+        end
+        
+      end
+    end
+
+  end
+  
+end

data/spec/csl/schema_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module CSL
+  describe 'Schema' do
+  
+    describe '.version' do
+      it 'returns a version string' do
+        Schema.version.should match(/^\d+\.\d+\.\d+/)
+      end
+      
+      it 'is greater than 1.0' do
+        Schema.version.split(/\./)[0].to_i.should >= 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]
+      end
+
+      it 'contains :date fields' do
+        Schema.variables[:date].should_not be_empty
+        Schema.variables[:dates].should equal Schema.variables[:date]
+      end
+
+      it 'contains :text fields' do
+        Schema.variables[:text].should_not be_empty
+      end
+
+      it 'contains :number fields' do
+        Schema.variables[:numbers].should_not be_empty
+        Schema.variables[:number].should_not be_empty
+      end
+      
+      it 'accepts either string or symbol input' do
+        Schema.variables[:names].should equal Schema.variables['names']
+      end  
+    end
+    
+    describe '.types' do
+      it 'returns an array' do
+        Schema.types.should be_a(Array)
+      end
+      
+      it 'is not empty' do
+        Schema.types.should_not be_empty
+      end
+      
+      it 'includes :article' do
+        Schema.types.should include(:article)
+      end
+    end
+    
+    describe '.categories' do
+      it 'given a field name returns the corresponding type' do
+        Schema.categories[:author].should == :names
+        Schema.categories[:issued].should == :date
+        Schema.categories[:abstract].should == :text
+        Schema.categories[:issue].should == :number
+      end
+      
+      it 'accepts either string or symbol input' do
+        Schema.categories.should have_key(:author)
+        Schema.categories['author'].should equal Schema.categories[:author]
+      end
+    end
+    
+  end
+end

data/spec/csl/style/bibliography_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module CSL
+  describe Style::Bibliography do
+  
+  end
+end

data/spec/csl/style/citation_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module CSL
+  describe Style::Citation do
+  
+  end
+end

data/spec/csl/style/conditional_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module CSL
+  describe Style::Conditional do
+  
+  end
+end

data/spec/csl/style/date_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+module CSL
+  describe Style::Date do
+  
+  end
+
+  describe Style::DatePart do
+  
+  end
+end

data/spec/csl/style/group_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module CSL
+  describe Style::Group do
+  
+  end
+end

data/spec/csl/style/label_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module CSL
+  describe Style::Label do
+  
+  end
+end

data/spec/csl/style/layout_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module CSL
+  describe Style::Layout do
+  
+  end
+end

data/spec/csl/style/macro_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module CSL
+  describe Style::Macro do
+  
+  end
+end

data/spec/csl/style/names_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module CSL
+  describe Style::Names do
+    
+  end
+
+  describe Style::Name do
+  
+  end
+
+  describe Style::NamePart do
+  
+  end
+
+  describe Style::EtAl do
+  
+  end
+
+  describe Style::Substitute do
+  
+  end
+end

data/spec/csl/style/number_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+module CSL
+  describe Style::Number do
+  
+    describe '.new' do
+      it 'returns an empty number tag by default' do
+        Style::Number.new.should_not have_attributes
+      end
+      
+      it 'accepts a form attribute' do
+        Style::Number.new(:form => 'roman').should be_roman
+      end
+    end
+    
+    describe '#numeric?' do
+      it 'returns true by default' do
+        Style::Number.new.should 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
+      end
+      
+      it 'returns false if the form attribute is set to :numeric' do
+        Style::Number.new(:form => 'numeric').should be_numeric
+      end
+    end
+
+    describe '#roman?' do
+      it 'returns false by default' do
+        Style::Number.new.should_not 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
+      end
+      
+      it 'returns false if the form attribute is set to :roman' do
+        Style::Number.new(:form => 'roman').should be_roman
+      end
+    end
+
+    describe '#ordinal?' do
+      it 'returns false by default' do
+        Style::Number.new.should_not 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
+      end
+      
+      it 'returns false if the form attribute is set to :ordinal' do
+        Style::Number.new(:form => 'ordinal').should be_ordinal
+      end
+    end
+
+    describe '#long_ordinal?' do
+      it 'returns false by default' do
+        Style::Number.new.should_not 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
+      end
+      
+      it 'returns false if the form attribute is set to :ordinal' do
+        Style::Number.new(:form => 'long-ordinal').should 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/>'
+      end
+      
+      it 'returns a tag with a all attribute assignments' do
+        Style::Number.new(:form => 'roman').to_xml.should == '<number form="roman"/>'
+      end
+    end
+    
+  end
+end

data/spec/csl/style/text_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module CSL
+  describe Style::Text do
+  
+  end
+end

data/spec/csl/style_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module CSL
+  describe Style do
+  
+    it { should be }
+    
+    it 'has a 1.x version by default' do
+      Style.new[:version].should match(/1\.\d+(\.\d+)?/) 
+    end
+    
+    describe '#to_xml' do
+      it 'returns an empty style' do
+        Style.new.to_xml.should match(/<style[^>]*\/>/)
+      end
+    end
+  
+  end
+end

data/spec/csl/treelike_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+module CSL
+	describe 'Treelike' do
+  
+	  before(:all) do 
+			class TestTree
+			  include Treelike
+			  
+			  def initialize
+			    @children = self.class.create_children
+			  end
+			end
+		end
+  
+	  let(:node) { TestTree.new }
+    
+    let(:lvl1) { TestTree.new.add_child(TestTree.new) }
+    let(:lvl2) { TestTree.new.add_child(TestTree.new).add_child(TestTree.new) }
+
+    it 'has no children by default' do
+      node.should_not have_children
+    end
+    
+    it 'is empty by default' do
+      node.should be_empty
+    end
+    
+    describe '#children' do
+      
+      it 'is empty by default' do
+        node.children.should be_empty
+      end
+      
+      it 'grows when adding child nodes' do
+        expect { node << TestTree.new }.to change { node.children.length }.by(1)
+      end
+      
+    end
+    
+	  describe '#nodename' do
+	    it 'returns the class name in attribute form by default' do
+	      node.nodename.should == 'test-tree'
+	    end
+	  end
+    
+	  describe '#ancestors' do
+      it 'returns and empty list by default' do
+        node.ancestors.should be_empty
+      end
+
+      it 'returns a list with one ancestor at level 1' do
+        lvl1.ancestors.should have(1).element
+      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
+      end
+
+      it 'returns a list with two ancestors at level 2' do
+        lvl2.ancestors.should have(2).elements
+      end      
+	  end
+
+    it 'is a root node by default' do
+      node.should be_root
+    end
+    
+	  describe '#root' do  
+	    it 'returns self at level 0' do
+	      node.root.should equal(node)
+	    end
+
+      it 'returns the parent at level 1' do
+        lvl1.root.should == lvl1.parent
+      end
+
+      it 'returns parent.parent at level 2' do
+        lvl2.root.should == lvl2.parent.parent
+      end
+	  end
+    
+    describe '#depth' do
+      it 'returns 0 by default' do
+        node.depth.should == 0
+      end
+
+      it 'returns 1 at level 1' do
+        lvl1.depth.should == 1
+      end
+
+      it 'returns 2 at level 2' do
+        lvl2.depth.should == 2
+      end
+      
+      it 'grows when the node is added to another node' do
+        expect { TestTree.new << node }.to change { node.depth }.by(1)
+      end
+      
+    end
+
+    describe 'named children' do
+      before(:all) do
+        class TestTree
+          attr_children :'test-tree'
+        end
+        class AnotherTree
+          include Treelike
+        end     
+      end
+    
+      it 'the class contains a children struct' do
+        TestTree.const?(:Children).should be true
+      end
+      
+      describe '.create_children' do
+        it 'returns the children struct' do
+          TestTree.create_children.should be_a(Struct)
+        end
+      end
+      
+      describe '#children' do
+        it 'returns a children struct instance' do
+          TestTree.new.children.should be_a(Struct)
+        end
+      end
+      
+      it 'has no children by default' do
+        TestTree.new.should_not have_children
+      end
+      
+      it 'has children when adding child nodes' do
+        expect { node << TestTree.new }.to change { node.has_children? }.to(true)
+      end
+
+      it 'raises an error when adding a child with an invalid name' do
+        expect { node << AnotherTree.new }.to raise_error(ValidationError)
+      end 
+    
+      it 'accepts multiple nodes of the same name' do
+        expect { node << TestTree.new << TestTree.new }.to change {
+          node.children.each.to_a.length
+        }.from(0).to(2)
+      end
+      
+    end
+    
+	end
+	
+end