csl 1.0.2 → 1.1.0

data/lib/csl/style/sort.rb

@@ -1,21 +1,77 @@
 module CSL
-  
-  class Sort < Node
-    
-    attr_children :key
-
-    alias keys key
-    
-    def initialize(attributes = {})
-      super(attributes)
-      children[:key] = []
-      
-      yield self if block_given?
-    end
-    
-    class Key < Node
+  class Style
+
+    class Sort < Node
+
+      attr_children :key
+
+      alias keys key
+
+      def initialize(attributes = {})
+        super(attributes)
+        children[:key] = []
+
+        yield self if block_given?
+      end
+
+      class Key < Node
+
+        attr_struct :variable, :macro, :sort,
+          :'names-use-min', :'names-use-first', :'names-use-last'
+
+        attr_defaults :sort => 'ascending'
+
+        has_no_children
+
+        def name_options
+          options = {}
+
+          options[:'et-al-use-min'] = options[:'et-al-subsequent-use-min'] =
+            attributes[:'names-use-min'] if attribute? :'names-use-min'
+
+          options[:'et-al-use-first'] = options[:'et-al-subsequent-use-first'] =
+            attributes[:'names-use-first'] if attribute? :'names-use-first'
+
+          options[:'et-al-use-last'] = options[:'et-al-subsequent-use-last'] =
+            attributes[:'names-use-last'] if attribute? :'names-use-last'
+
+          options
+        end
+
+        def ascending?
+          attributes[:sort] =~ /^ascending$/i
+        end
+
+        def ascending!
+          attributes[:sort] = 'ascending'
+        end
+
+        def descending?
+          !ascending?
+        end
+
+        def descending!
+          attributes[:sort] = 'descending'
+        end
+
+        def macro?
+          attribute? :macro
+        end
+
+        def macro
+          fail 'cannot resolve macro: not associated with style' unless
+            !root? && root.respond_to?(:macros)
+
+          root.macros[attributes[:macro].to_s]
+        end
+
+        def variable
+          attributes[:variable]
+        end
+
+      end
+
     end
-    
+
   end
-  
-end
+end

data/lib/csl/style/text.rb

@@ -14,7 +14,7 @@ module CSL
       def variable
         attributes[:variable]
       end
-      
+
       def variable_options
         attributes_for :form
       end
@@ -25,8 +25,10 @@ module CSL
 
       # @return [Macro, nil]
       def macro
-        raise unless parent.respond_to?(:macros)
-        parent.macros[attributes[:macro]]
+        raise "failed to resolve macro #{attributes[:macro].inspect}" unless
+          !root? && root.respond_to?(:macros)
+
+        root.macros[attributes[:macro]]
       end
 
       def has_term?
@@ -43,4 +45,4 @@ module CSL
     end
 
   end
-end
+end

data/lib/csl/treelike.rb

@@ -32,7 +32,7 @@ module CSL
       end
     end
     alias delete delete_children
-    
+
     # Deletes child nodes that are equal to the passed-in node. Returns all
     # deleted children. If no children were deleted, returns nil. If the
     # optional block is given, returns the result block if no children were
@@ -114,6 +114,17 @@ module CSL
     end
     alias >> find_children
 
+    def closest(name, conditions = {})
+      case
+      when root?
+        nil
+      when parent.match?(name, conditions)
+        parent
+      else
+        parent.closest(name, conditions)
+      end
+    end
+
     # @return [Boolean] true if this node has child nodes; false otherwise.
     def has_children?
       !empty?
@@ -287,7 +298,7 @@ module CSL
       # standard Array that normally holds the child nodes. The benefit of
       # using the Struct is that all child nodes are accessible by name and
       # need not be looked up; this improves performance, however, note that
-      # a node defining it's children that way can only contain nodes of the
+      # a node defining its children that way can only contain nodes of the
       # given types.
       #
       # This method also generates accessors for each child. The writer
@@ -324,7 +335,7 @@ module CSL
                 raise ArgumentError, "failed to convert #{value.inspect} to node: #{e.message}"
               end unless value.respond_to?(:nodename)
 
-              children << value
+              add_child value
               value
             end
 
@@ -437,7 +448,7 @@ module CSL
           private
 
           def resolve(nodename)
-            keys.include?(nodename.to_sym) && send(nodename)
+            keys.include?(nodename.to_sym) && self[nodename]
           end
         })
       end
@@ -474,4 +485,4 @@ module CSL
     end
 
   end
-end
+end

data/lib/csl/version.rb

@@ -1,3 +1,3 @@
-module CSL  
-  VERSION = '1.0.2'.freeze
+module CSL
+  VERSION = '1.1.0'.freeze
 end

data/spec/csl/locale/term_spec.rb

@@ -4,13 +4,13 @@ require 'spec_helper'
 module CSL
   describe Locale::Terms do
 
-		it { should_not be nil }
+    it { should_not be nil }
 
-		describe '#to_xml' do
-			it 'returns <terms/> by default' do
-				subject.to_xml.should == '<terms/>'
-			end
-		end
+    describe '#to_xml' do
+      it 'returns <terms/> by default' do
+        subject.to_xml.should == '<terms/>'
+      end
+    end
 
     describe '.specialize' do
       it 'filters the passed in hash to contain only match-able entries' do
@@ -18,40 +18,40 @@ module CSL
       end
     end
 
-		describe '#ordinalize' do
+    describe '#ordinalize' do
 
-		  describe "given standard English terms" do
-  		  let(:en) do
-  		    Locale::Terms.parse <<-EOS
-  	      <terms>
-    	      <term name="ordinal">th</term>
+      describe "given standard English terms" do
+        let(:en) do
+          Locale::Terms.parse <<-EOS
+          <terms>
+            <term name="ordinal">th</term>
             <term name="ordinal-01">st</term>
             <term name="ordinal-02">nd</term>
             <term name="ordinal-03">rd</term>
             <term name="ordinal-11">th</term>
             <term name="ordinal-12">th</term>
             <term name="ordinal-13">th</term>
-  	      </terms>
-  	      EOS
-  		  end
+          </terms>
+          EOS
+        end
 
         %w{
           ordinal ordinal-01 ordinal-02 ordinal-03 ordinal
         }.each_with_index do |ordinal, number|
-  		    it "returns #{ordinal.inspect} for #{number}" do
-  		      en.ordinalize(number)[:name].should == ordinal
-  		    end
-  		  end
-		  end
+          it "returns #{ordinal.inspect} for #{number}" do
+            en.ordinalize(number)[:name].should == ordinal
+          end
+        end
+      end
 
-		end
+    end
 
     describe '#lookup' do
 
-		  describe "given standard English terms" do
-  		  let(:en) do
-  		    Locale::Terms.parse <<-EOS
-  	      <terms>
+      describe "given standard English terms" do
+        let(:en) do
+          Locale::Terms.parse <<-EOS
+          <terms>
             <term name="page" form="short">
               <single>p.</single>
               <multiple>pp.</multiple>
@@ -79,42 +79,42 @@ module CSL
             </term>
             <term name="editor" form="verb">edited by</term>
             <term name="editor" form="verb-short">ed.</term>
-  	      </terms>
-  	      EOS
-  		  end
+          </terms>
+          EOS
+        end
 
-  		  it 'returns nil if there is no matching term' do
-  		    en.lookup(:foo).should be_nil
-  		  end
+        it 'returns nil if there is no matching term' do
+          en.lookup(:foo).should be_nil
+        end
 
-  		  it 'returns the long form by default' do
-  		    en.lookup(:page).should be_long
-  		  end
+        it 'returns the long form by default' do
+          en.lookup(:page).should be_long
+        end
 
-  		  it 'returns the term in the passed-in form if available' do
-  		    en.lookup(:section, :form => 'long').should be_long
-  		    en.lookup(:section, :form => 'short').should be_short
-  		    en.lookup(:section, :form => 'symbol').should be_symbol
+        it 'returns the term in the passed-in form if available' do
+          en.lookup(:section, :form => 'long').should be_long
+          en.lookup(:section, :form => 'short').should be_short
+          en.lookup(:section, :form => 'symbol').should be_symbol
 
-  		    en.lookup(:editor).should be_long
-  		    en.lookup(:editor, :form => 'long').should be_long
-  		    en.lookup(:editor, :form => 'verb').should be_verb
-  		    en.lookup(:editor, :form => 'verb-short').should be_verb_short
-  		  end
+          en.lookup(:editor).should be_long
+          en.lookup(:editor, :form => 'long').should be_long
+          en.lookup(:editor, :form => 'verb').should be_verb
+          en.lookup(:editor, :form => 'verb-short').should be_verb_short
+        end
 
-  		  it 'returns the right fallback form if the passed-in form is not available' do
-  		    en.lookup(:page, :form => 'verb').should be_long
-  		    en.lookup(:page, :form => 'verb-short').should be_long
-  		    en.lookup(:page, :form => 'symbol').should be_short
+        it 'returns the right fallback form if the passed-in form is not available' do
+          en.lookup(:page, :form => 'verb').should be_long
+          en.lookup(:page, :form => 'verb-short').should be_long
+          en.lookup(:page, :form => 'symbol').should be_short
         end
 
-  		  it 'ignores irrelevant options' do
-  		    en.lookup(:page, :plural => true).should_not be_nil
-  		  end
-  		end
+        it 'ignores irrelevant options' do
+          en.lookup(:page, :plural => true).should_not be_nil
+        end
+      end
 
     end
-	end
+  end
 
   describe Locale::Term do
 
@@ -129,13 +129,13 @@ module CSL
     it { should_not be_short_ordinal }
     it { should_not be_long_ordinal }
 
-		it 'is not a textnode by default' do
-			subject.should_not be_textnode
-		end
+    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
+    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' } }
@@ -237,19 +237,19 @@ module CSL
       end
     end
 
-		describe '#to_xml' do
-			it 'returns <term/> by default' do
-				subject.to_xml.should == '<term/>'
-			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>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
+      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
-end
+end

data/spec/csl/locale_spec.rb

@@ -4,35 +4,35 @@ require 'spec_helper'
 
 module CSL
 
-	describe Locale do
+  describe Locale do
 
-		let(:locale) { Locale.new }
+    let(:locale) { Locale.new }
 
-		let(:en) { Locale.new('en-US') }
-		let(:gb) { Locale.new('en-GB') }
-		let(:de) { Locale.new('de-DE') }
+    let(:en) { Locale.new('en-US') }
+    let(:gb) { Locale.new('en-GB') }
+    let(:de) { Locale.new('de-DE') }
 
-		describe '.regions' do
+    describe '.regions' do
 
-			it 'returns the default region when passed a language symbol' do
-				Locale.regions[:en].should == :US
-			end
+      it 'returns the default region when passed a language symbol' do
+        Locale.regions[:en].should == :US
+      end
 
-		end
+    end
 
-		describe '.languages' do
+    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
+      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
+    end
 
-		describe '.normalize' do
+    describe '.normalize' do
       {
         'en' => 'en-US',
         '-GB' => 'en-GB',
@@ -43,18 +43,18 @@ module CSL
           Locale.normalize(tag).should == expected
         end
       end
-		end
+    end
 
-		describe '.new' do
-			it { should_not be_nil }
+    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 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 '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
@@ -64,7 +64,7 @@ module CSL
         Locale.new.terms.should be_nil
       end
 
-		end
+    end
 
     describe '.load' do
 
@@ -87,80 +87,121 @@ module CSL
 
     end
 
-		describe '#set' do
+    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 "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 "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
+      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
+    end
 
-		describe '#merge!' do
-		  let(:locale_with_options) { Locale.new('en', :foo => 'bar') }
+    describe '#merge!' do
+      let(:locale_with_options) { Locale.new('en', :foo => 'bar') }
 
-		  describe 'style options' do
-  		  it 'does not change the options if none are set on either locale' do
-  		    expect { locale.merge!(en) }.not_to change { locale.options }
-  		  end
+      describe 'style options' do
+        it 'does not change the options if none are set on either locale' do
+          expect { locale.merge!(en) }.not_to change { locale.options }
+        end
 
-  		  it 'creates a duplicate option element if the first locale has no options' do
-  		    locale.should_not have_options
-  		    locale.merge!(locale_with_options)
-  		    locale.should have_options
-  		    locale.options[:foo].should == 'bar'
+        it 'creates a duplicate option element if the first locale has no options' do
+          locale.should_not have_options
+          locale.merge!(locale_with_options)
+          locale.should have_options
+          locale.options[:foo].should == 'bar'
           locale.options.should_not equal(locale_with_options.options)
-  		  end
-
-  		  it 'merges the options if both locales have options' do
-  		    locale << Locale::StyleOptions.new(:bar => 'foo')
-  		    
-  		    expect { locale.merge!(locale_with_options) }.not_to change { locale.options.object_id }
-  		    
-  		    locale.options[:foo].should == 'bar'
-  		    locale.options[:bar].should == 'foo'
-  		  end
-
-  		  it 'overrides the options with those in the other locale' do
-  		    locale << Locale::StyleOptions.new(:bar => 'foo', :foo => 'foo')
-  		    locale.merge!(locale_with_options)
-  		    locale.options[:foo].should == 'bar'
-  		    locale.options[:bar].should == 'foo'
-  		  end
-  		end
-  		
-  		describe 'dates' do
-  		  it 'does not change the dates if none are set on either locale' do
-  		    expect { locale.merge!(en) }.not_to change { locale.dates }
-  		  end
-  		  
-  		  it 'creates duplicate date elements if the first locale has no options' do
-  		    locale.merge!(Locale.load('en-US'))
-  		    locale.should have_dates
-  		  end
-  		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 = '0.8'
-		    locale.should be_legacy
-		  end
-		end
-
-	end
-end
+        end
+
+        it 'merges the options if both locales have options' do
+          locale << Locale::StyleOptions.new(:bar => 'foo')
+
+          expect { locale.merge!(locale_with_options) }.not_to change { locale.options.object_id }
+
+          locale.options[:foo].should == 'bar'
+          locale.options[:bar].should == 'foo'
+        end
+
+        it 'overrides the options with those in the other locale' do
+          locale << Locale::StyleOptions.new(:bar => 'foo', :foo => 'foo')
+          locale.merge!(locale_with_options)
+          locale.options[:foo].should == 'bar'
+          locale.options[:bar].should == 'foo'
+        end
+      end
+
+      describe 'dates' do
+        it 'does not change the dates if none are set on either locale' do
+          expect { locale.merge!(en) }.not_to change { locale.dates }
+        end
+
+        it 'creates duplicate date elements if the first locale has no options' do
+          locale.merge!(Locale.load('en-US'))
+          locale.should have_dates
+        end
+      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 = '0.8'
+        locale.should be_legacy
+      end
+    end
+
+    describe '#quote' do
+
+      it 'quotes the passed-in string' do
+        locale.store 'open-quote', '»'
+        locale.store 'close-quote', '«'
+
+        locale.quote('foo').should == '»foo«'
+      end
+
+      it 'does not alter the string if there are no quotes in the locale' do
+        locale.quote('foo').should == 'foo'
+      end
+
+      it 'adds quotes inside final punctuation if punctuation-in-quote option is set' do
+        locale.store 'open-quote', '»'
+        locale.store 'close-quote', '«'
+
+        locale.quote('foo.').should == '»foo«.'
+        locale.quote('foo,').should == '»foo«,'
+
+        locale.quote('foo!').should == '»foo!«'
+        locale.quote('foo?').should == '»foo?«'
+
+        locale.punctuation_in_quotes!
+
+        locale.quote('foo.').should == '»foo.«'
+        locale.quote('foo,').should == '»foo,«'
+
+        locale.quote('foo!').should == '»foo!«'
+        locale.quote('foo?').should == '»foo?«'
+      end
+
+      it 'replaces existing quotes with inner quotes' do
+        locale.store 'open-quote', '“'
+        locale.store 'close-quote', '”'
+        locale.store 'open-inner-quote', '‘'
+        locale.store 'close-inner-quote', '’'
+
+        locale.quote('“foo”').should == '“‘foo’”'
+      end
+    end
+  end
+end