csl 1.0.0.pre1

data/lib/csl/version.rb

@@ -0,0 +1,3 @@
+module CSL  
+  VERSION = '1.0.0.pre1'.freeze
+end

data/spec/csl/info_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+module CSL
+  
+  describe Info do
+    
+    it { should_not be_nil }
+    it { should_not have_children }
+    
+    describe '#nodename' do
+      it 'returns "info"' do
+        subject.nodename.should == 'info'
+      end
+    end
+    
+    describe '#children' do
+      it 'returns a Info::Children instance' do
+        Info.new.children.should be_a(Info::Children)
+      end
+      
+      it 'allows to set the id by writer method' do
+        lambda { Info.new.children.id = 'foo' }.should_not raise_error
+      end
+
+      it 'allows to set the id by array accessor' do
+        lambda { Info.new.children[:id] = 'foo' }.should_not raise_error
+      end
+    end
+
+    describe '#category' do
+      it 'returns nil by default' do
+        Info.new.category.should be nil
+      end
+    end
+    
+    describe '#to_xml' do
+      it 'returns an empty info element by default' do
+        subject.to_xml.should == '<info/>'
+      end
+      
+      it 'prints the id if present' do
+        Info.new { |i| i.set_child_id 'apa' }.to_xml.should == '<info><id>apa</id></info>'
+      end
+
+      it 'prints the category if present' do
+        Info.new { |i| i.category = 'author' }.to_xml.should == '<info><category>author</category></info>'
+      end
+      
+    end
+    
+  end
+  
+  describe Info::Author do
+    it { should_not be_nil }
+
+    let(:poe) {
+      Info::Author.new { |a|
+        a.email = 'poe@baltimore.com'
+        a.name = 'E. A. Poe'
+      }
+    }
+
+    describe '#name' do
+      it 'returns nil by default' do
+        subject.name.should be nil
+      end
+      
+      it 'returns the name if set' do
+        poe.name.to_s.should == 'E. A. Poe'
+      end      
+    end
+
+    describe '#email' do
+      it 'returns the email' do
+        poe.email.to_s.should == 'poe@baltimore.com'
+      end
+    end
+    
+    describe '#to_xml' do
+      it 'returns an empty author by default' do
+        subject.to_xml.should == '<author/>'
+      end
+            
+      it 'prints all children' do
+        poe.to_xml.should == '<author><name>E. A. Poe</name><email>poe@baltimore.com</email></author>'
+      end      
+    end
+    
+  end
+  
+  describe Info::Contributor do
+    
+    it { should_not be_nil }
+    
+    let(:bruce) { Info::Contributor.new { |c| c.name = "Bruce D'Arcus" } }
+    
+    describe '#name' do
+      it 'returns the name' do
+        bruce.name.to_s.should == "Bruce D'Arcus"
+      end
+    end
+    
+    
+    describe '#to_xml' do
+      it 'returns an empty contributor by default' do
+        subject.to_xml.should == '<contributor/>'
+      end
+      
+      it 'prints the name tag if present' do
+        bruce.to_xml.should == "<contributor><name>Bruce D'Arcus</name></contributor>"
+      end      
+    end
+    
+  end
+  
+end

data/spec/csl/locale/date_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module CSL
+
+  describe Locale::Date do
+  
+    let(:date) { Locale::Date.new }
+    
+    it { should_not be_nil }
+    
+    it { should_not be_text }
+    it { should_not be_numeric }
+  
+    describe '#parts' do
+      
+      it 'returns nil by default' do
+        date.parts.should be_empty
+      end
+      
+    end
+    
+    describe '#to_xml' do
+      
+      it 'returns <date/> by default' do
+        Locale::Date.new.to_xml.should == '<date/>'
+      end
+
+      it 'returns <date form="numeric"/> for an empty numeric date' do
+        Locale::Date.new(:form => 'numeric').to_xml.should == '<date form="numeric"/>'
+      end
+      
+    end
+    
+  end
+
+  describe Locale::DatePart do
+
+    it { should_not be_nil }
+    
+    it { should_not be_day }
+    it { should_not be_month }
+    it { should_not be_year }
+  
+    describe '#to_xml' do
+      
+      it 'returns <date-part/> by default' do
+        Locale::DatePart.new.to_xml.should == "<date-part/>"
+      end
+      
+      it 'returns <date-part name="year"/> when the name is "year"' do
+        Locale::DatePart.new(:name => 'year').to_xml.should == '<date-part name="year"/>'
+      end
+      
+      it 'returns <date-part name="month" form="numeric" prefix="-"/> for a numeric month with prefix "-"' do
+        Locale::DatePart.new(:name => 'month', :form => 'numeric', :prefix => '-').to_xml.should match(/(\s(name|form|prefix)="[^"]+"){3}/)
+      end
+      
+    end
+    
+  end
+
+
+end

data/spec/csl/locale/style_options_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module CSL  
+  describe Locale::StyleOptions do
+  
+    it { should_not be nil }
+    
+    it 'punctuation-in-quote is false by default' do
+      subject[:'punctuation-in-quote'].should be false
+    end
+    
+    describe '#to_xml' do
+      it 'returns <style-options punctuation-in-quote="false"/> by default' do
+        subject.to_xml.should == '<style-options punctuation-in-quote="false"/>'
+      end
+    end
+    
+  end
+end

data/spec/csl/locale/term_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module CSL
+  describe Locale::Terms do
+	
+		it { should_not be nil }
+
+		describe '#to_xml' do
+			it 'returns <terms/> by default' do
+				subject.to_xml.should == '<terms/>'
+			end
+		end
+		
+	end
+	
+  describe Locale::Term do
+
+    it { should_not be_nil }
+
+    it { should_not be_gendered }
+
+    it { should be_neutral }
+
+		it 'is not a textnode by default' do
+			subject.should_not be_textnode
+		end
+
+		it 'is a textnode when the text is "foo"' do
+			Locale::Term.new { |t| t.text = 'foo' }.should be_textnode
+		end
+
+    describe 'gender attribute is set' do
+      let(:m) { Locale::Term.new(:name => 'month-05') { |t| t.masculine!; t.text = 'Mai' } } 
+      let(:f) { Locale::Term.new(:name => 'edition') { |t| t.feminine!; t.text = 'Ausgabe' } } 
+      
+      it 'is gendered' do
+        m.should be_gendered
+        f.should be_gendered
+      end
+
+      it 'is feminine or masculine' do
+        m.should be_masculine
+        f.should be_feminine
+      end
+      
+      it 'is not neutral' do
+        m.should_not be_neutral
+        f.should_not be_neutral
+      end
+      
+      describe '#to_xml' do
+        it 'contains the correct gender' do
+          m.to_xml.should =~ /gender="masculine"/
+          f.to_xml.should =~ /gender="feminine"/
+        end
+      end
+      
+      describe '#match?' do
+        it 'matches the name when passed a string' do
+          m.matches?('month-05').should be_true
+        end
+
+        it 'matches the name when passed a pattern' do
+          m.matches?(/month-\d\d/).should be_true
+        end
+        
+        it 'does not match when passed a matching hash without gender' do
+          f.matches?(:name => 'edition').should_not be_true
+        end
+
+        it 'does not match when passed a matching hash with wrong gender' do
+          f.matches?(:name => 'edition', :gender => 'masculine').should_not be_true
+        end
+        
+        it 'matches when passed a matching hash with matching gender' do
+          f.matches?(:name => 'edition', :gender => 'feminine').should be_true
+        end
+      end
+    end
+    
+		describe '#to_xml' do
+			it 'returns <term/> by default' do
+				subject.to_xml.should == '<term/>'
+			end
+			
+			it 'returns <term>foo</term> when the text is "foo"' do
+				Locale::Term.new { |t| t.text = 'foo' }.to_xml.should == '<term>foo</term>'
+			end
+
+			it 'returns <term><multiple>foo</multiple></term> when multiple is "foo"' do
+				Locale::Term.new { |t| t.multiple = 'foo' }.to_xml.should == '<term><multiple>foo</multiple></term>'
+			end
+			
+		end
+  end
+end

data/spec/csl/locale_spec.rb

@@ -0,0 +1,128 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+module CSL
+
+	describe Locale do
+
+		let(:locale) { Locale.new }
+
+		let(:en) { Locale.new('en-US') }
+		let(:de) { Locale.new('de-DE') }
+		let(:fr) { Locale.new('fr-FR') }
+
+		describe '.regions' do
+			
+			it 'returns the default region when passed a language symbol' do
+				Locale.regions[:en].should == :US
+			end
+			
+		end
+		
+		describe '.languages' do
+			
+			describe 'the language hash' do
+				it 'returns the default language when passed a region string' do
+					%w{ US en GB en AT de DE de }.map(&:to_sym).each_slice(2) do |region, language|
+						Locale.languages[region].should == language
+					end
+				end
+			end			
+			
+		end
+		
+		describe '.new' do
+			it { should_not be_nil }
+
+			it 'defaults to default language' do
+				Locale.new.language.should == Locale.default.split(/-/)[0].to_sym
+			end
+
+			it 'defaults to default region' do
+				Locale.new.region.should == Locale.default.split(/-/)[1].to_sym
+			end
+
+      it 'contains no dates by default' do
+        Locale.new.dates.should be_nil
+      end
+
+      it 'contains no terms by default' do
+        Locale.new.terms.should be_nil
+      end
+      
+		end
+
+    describe '.load' do
+      
+      describe 'when called with "en-GB" ' do
+        let(:locale) { Locale.load('en-GB') }
+        
+        it 'the returned locale has the correct IETF tag' do
+          locale.to_s.should == 'en-GB'
+        end
+      
+        it 'the locale has language :en' do
+          locale.language.should == :en
+        end
+
+        it 'the locale has region :GB' do
+          locale.region.should == :GB
+        end
+        
+      end
+      
+    end
+
+		describe '#set' do			
+			
+			it 'when passed "en-GB" sets language to :en and region to :GB' do
+				locale.set('en-GB')
+				[locale.language, locale.region].should == [:en, :GB]
+			end
+
+			it 'when passed "de" sets language to :de and region to :DE' do
+				locale.set('de')
+				[locale.language, locale.region].should == [:de, :DE]
+			end
+
+			it 'when passed "-AT" sets language to :de and region to :AT' do
+				locale.set('-AT')
+				[locale.language, locale.region].should == [:de, :AT]
+			end
+			
+		end
+		
+		describe '#legacy?' do
+		  it 'returns false by default' do
+		    locale.should_not be_legacy
+		  end
+		  
+		  it 'returns true if the version is less than 1.0.1' do
+		    locale.version = '1.0'
+		    locale.should be_legacy
+		  end
+		end
+		
+		describe '#ordinalize_query_for' do
+		  
+		  it 'returns { :name => "ordinal-%02d" } by default' do
+		    locale.send(:ordinalize_query_for, nil).should == { :name => "ordinal-%02d" }
+		  end
+
+		  it 'returns { :name => "ordinal-%02d" } for { :form => :short }' do
+		    locale.send(:ordinalize_query_for, { :form => :short }).should == { :name => "ordinal-%02d" }
+		  end
+
+		  it 'returns { :name => "long-ordinal-%02d" } for { :form => :long }' do
+		    locale.send(:ordinalize_query_for, { :form => :long }).should == { :name => "long-ordinal-%02d" }
+		  end
+
+		  it 'returns { :name => "ordinal-%02d", :"gender-form" => "feminine" } for { :gender => :feminine }' do
+		    locale.send(:ordinalize_query_for, { :gender => :feminine }).should == { :name => "ordinal-%02d", :'gender-form' => 'feminine' }
+		  end
+		  
+		end
+		
+	end
+end

data/spec/csl/node_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+module CSL
+	
+	describe Node do
+
+    it { should_not be nil }
+    it { should_not have_children }
+    it { should_not have_attributes }
+		
+		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
+        end
+        class TestNode < Node
+        end
+      end
+      
+      it 'creates FooBarNode::Attributes' do
+        FooBarNode.const_defined?(:Attributes).should be_true
+      end
+      
+      it 'does not create TestNode::Attributes' do
+        TestNode.const_defined?(:Attributes).should_not be_true
+      end
+		  
+		  it 'TestNode attributes are a regular Hash' do
+		    TestNode.new.attributes.should be_a(Hash)
+		  end
+
+		  it 'FooBarNode attributes are a Struct' do
+		    FooBarNode.new.attributes.should be_a(Struct)
+		  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 }
+  		  end
+  		  
+  		  it 'TestNode accepts attribute names' do
+  		    TestNode.new(:foo => 'Foo', :bar => 'Bar').values_at(:bar, :foo).should == %w{ Bar Foo }
+  		  end
+      end
+      
+      describe '#to_a' do
+        it 'returns an empty list by default' do
+          Node.new.attributes.to_a.should == []
+        end
+
+        it 'TestNode returns an empty list by default' do
+          TestNode.new.attributes.to_a.should == []
+        end
+        
+        # it 'TestNode returns a list of all key/value pairs' do
+        #   TestNode.new(:foo => 'Foo', :bar => 'Bar').attributes.to_a.map(&:last).sort.should == %w{ Bar Foo }
+        # end
+
+        # it 'FooBarNode returns an empty list by default' do
+        #   FooBarNode.new.attributes.to_a.should == []
+        # end
+  		  
+        # it 'FooBarNode returns a list of all key/value pairs' do
+        #   FooBarNode.new(:foo => 'Foo', :bar => 'Bar').attributes.to_a.map(&:last).sort.should == %w{ Bar Foo }
+        # end
+      end
+      
+      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]
+        end
+      end
+    end
+	end
+
+  describe TextNode do
+    
+    it { should_not be nil }
+    it { should_not have_children }
+    it { should_not have_attributes }
+    
+    describe '.new' do
+      it 'accepts a hash of attributes' do
+        TextNode.new(:foo => 'bar').should have_attributes
+      end
+      
+      it 'yields itself to the optional block' do
+        TextNode.new { |n| n.text = 'foo' }.text.should == '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>'
+      end
+      
+    end
+    
+  end
+  
+end