csl 1.0.0.pre5 → 1.0.0.pre6

data/lib/csl/locale/ordinalize.rb

@@ -0,0 +1,130 @@
+module CSL
+  class Locale
+    
+    # Ordinalizes the passed-in number using either the ordinal or
+    # long-ordinal forms defined by the locale. If a long-ordinal form is
+    # requested but not available, the regular ordinal will be returned
+    # instead.
+    #
+    # @example
+    #   Locale.load('en').ordinalize(13)
+    #   #-> "13th"
+    #
+    #   de = Locale.load('de')
+    #   de.ordinalize(13)
+    #   #-> "13."
+    #
+    #   de.ordinalize(3, :form => :long, :gender => :feminine)
+    #   #-> "dritte"
+    #
+    # @note
+    #   For CSL 1.0 (and older) locales that do not define an "ordinal-00"
+    #   term the algorithm specified by CSL 1.0 is used; otherwise uses the
+    #   CSL 1.0.1 algorithm with improved support for languages other than
+    #   English.
+    #
+    # @param number [#to_i] the number to ordinalize
+    # @param options [Hash] formatting options
+    #
+    # @option options [:short,:long] :form (:short) which ordinals form to use
+    # @option options [:feminine,:masculine,:neutral] :gender (:neutral)
+    #   which ordinals gender-form to use
+    #
+    # @raise [ArgumentError] if number cannot be converted to an integer
+    #
+    # @return [String] the ordinal for the passed-in number
+    def ordinalize(number, options = {})
+      raise ArgumentError, "unable to ordinalize #{number}; integer expected" unless
+        number.respond_to?(:to_i)
+
+      number, query = number.to_i, ordinalize_query_for(options)
+
+      key = query[:name]
+
+      # Try to match long-ordinals first
+      if key.start_with?('l')
+        query[:name] = key % number.abs
+        ordinal = terms[query]
+
+        if ordinal.nil?
+          key = 'ordinal-%02d'
+        else
+          return ordinal.to_s(options)
+        end
+      end
+
+      # CSL 1.0 (legacy algorithm)      
+      return legacy_ordinalize(number) if legacy?
+
+      #
+      # CSL 1.0.1
+      #
+
+      # Calculate initial modulus
+      mod = 10 ** Math.log10([number.abs, 1].max).to_i
+
+      # Try to find direct match first
+      query.merge! :name => key % number.abs
+      ordinal = terms[query]
+
+      # Try to match modulus of number, dividing mod by 10 at each
+      # iteration until a match is found
+      while ordinal.nil? && mod > 1
+        query.merge! :name => key % (number.abs % mod)        
+        ordinal = terms.lookup_modulo(query, mod)
+
+        mod = mod / 10
+      end
+
+      # If we have not found a match at this point, we try to match
+      # the default ordinal instead
+      if ordinal.nil?
+        query[:name] = 'ordinal'
+        ordinal = terms[query]
+        
+        if ordinal.nil? && query.key?(:'gender-form')
+          query.delete(:'gender-form')
+          ordinal = terms[query]
+        end
+      end
+      
+      if ordinal.nil?
+        number.to_s
+      else
+        [number, ordinal.to_s(options)].join
+      end
+    end
+    
+    private
+    
+    # @return [Hash] a valid ordinalize query; the name attribute is a format string
+    def ordinalize_query_for(options)
+      q = { :name => 'ordinal-%02d' }
+
+      unless options.nil?
+        if options.key?(:form) && options[:form].to_s =~ /^long(-ordinal)?$/i
+          q[:name] = 'long-ordinal-%02d'
+        end
+
+        gender = (options[:'gender-form'] || options[:gender]).to_s
+        unless gender.empty? || gender =~ /^n/i
+          q[:'gender-form'] = (gender =~ /^m/i) ? 'masculine' : 'feminine'
+        end
+      end
+
+      q
+    end
+
+    def legacy_ordinalize(number)
+      case
+      when (11..13).include?(number.abs % 100)
+        [number, terms['ordinal-04']].join
+      when (1..3).include?(number.abs % 10)
+        [number, terms['ordinal-%02d' % (number.abs % 10)]].join
+      else
+        [number, terms['ordinal-04']].join
+      end
+    end
+    
+  end
+end

data/lib/csl/locale/term.rb

@@ -1,91 +1,128 @@
 module CSL
   class Locale
-    
+
     class Terms < Node
       attr_children :term
-      
+
       alias terms term
       def_delegators :terms, :size, :length
-      
+
       undef_method :[]=
-      
+
       def initialize(attributes = {})
-        super(attributes)      
+        super(attributes)
         @registry, children[:term] = Hash.new { |h,k| h[k] = [] }, []
 
         yield self if block_given?
       end
 
       alias each each_child
-      
+
       def lookup(query)
         query = { :name => query } unless query.is_a?(Hash)
-        
+
         terms = if query[:name].is_a?(Regexp)
           registry.select { |name, _| name =~ query[:name] }.flatten(1)
         else
           registry[query[:name].to_s]
         end
 
-        terms.detect { |t| t.exact_match?(query) }
+        terms.detect { |t| t.match?(query) }
       end
-      
+
       alias [] lookup
+
+      def lookup_modulo(query, divisor)
+        term = lookup(query)
+        return if term.nil? || !term.match_modulo?(divisor)
+        term
+      end
       
       private
-      
+
       # @!attribute [r] registry
       # @return [Hash] a private registry to map term names to the respective
       #   term objects for quick term look-up
       attr_reader :registry
-      
+
       def added_child(term)
         raise ValidationError, "failed to register term #{term.inspect}: name attribute missing" unless
           term.attribute?(:name)
-          
+
         registry[term[:name]].push(term)
         term
       end
-      
+
       def deleted_child(term)
         registry[term[:name]].delete(term)
       end
     end
-    
+
     class Term < Node
-      attr_struct :name, :form, :gender, :'gender-form'
+      attr_struct :name, :form, :gender, :'gender-form', :match
       attr_children :single, :multiple
 
       attr_accessor :text
 
       def_delegators :attributes, :hash, :eql?, :name, :form, :gender
 
+      # This method returns whether or not the ordinal term matchs the
+      # passed-in modulus. This is determined by the ordinal term's match
+      # attribute: a value of '2-digits' matches a divisor of 100, '1-digit'
+      # matches a divisor of 10 and 'whole-number' matches a divisor of 1.
+      #
+      # If the term is no ordinal term, this methods always returns false.
+      #
+      # @return [Boolean] whether or not the ordinal term matches the
+      #   passed-in divisor.
+      def match_modulo?(divisor)
+        return false unless ordinal?
+        
+        case attributes.match
+        when '2-digits'
+          divisor.to_i == 100
+        when '1-digit'
+          divisor.to_i == 10
+        when 'whole-number'
+          divisor.to_i == 1
+        else
+          true
+        end
+      end
+
+      alias matches_modulo? match_modulo?
+      
+      # @return [Boolean] whether or not this term is an ordinal term
+      def ordinal?
+        /^ordinal(-\d\d+)?$/ === attributes.name
+      end
+        
       def gendered?
         !attributes.gender.blank?
       end
-    
+
       def neutral?
         !gendered?
       end
-  
+
       def textnode?
         !text.blank?
       end
-      
+
       def singularize
         return text if textnode?
         children.single.to_s
       end
 
       alias singular singularize
-      
+
       def pluralize
         return text if textnode?
         children.multiple.to_s
-      end      
+      end
+
+      alias plural pluralize
 
-      alias plural pluralize      
-      
       # @!method masculine?
       # @return [Boolean] whether or not the term is masculine
 
@@ -103,7 +140,7 @@ module CSL
         define_method("#{name}?") do
           attributes.gender.to_s == name
         end
-        
+
         define_method("#{name}!") do
           return nil if attributes.gender.to_s == name
           attributes.gender = name
@@ -139,21 +176,21 @@ module CSL
           end
         end
       end
-      
+
       class Single   < TextNode; end
       class Multiple < TextNode; end
-      
+
       private
-      
+
       def pluralize?(options)
         return false if options.nil?
-        
+
         case
         when options.key?(:plural) || options.key?('plural')
           options[:plural] || options['plural']
         when options.key?(:number) || options.key?('number')
           key = options[:number] || options['number']
-        
+
           if key.is_a?(Fixnum) || key.to_s =~ /^[+-]?\d+$/
             key.to_i > 1
           else
@@ -163,9 +200,9 @@ module CSL
           false
         end
       end
-        
+
     end
-       
+
     TextNode.types << Term
   end
 end

data/lib/csl/node.rb

@@ -68,6 +68,28 @@ module CSL
 
       private
 
+			def has_language				
+				attr_accessor :language
+				
+				define_method :has_language? do
+					!language.nil?
+				end
+				
+				public :language, :language=, :has_language?
+				
+				alias_method :original_attribute_assignments, :attribute_assignments
+				
+				define_method :attribute_assignments do
+					if has_language?
+			  		original_attribute_assignments.unshift('xml:lang="%s"' % language)
+					else
+						original_attribute_assignments
+					end
+			  end
+			
+				private :original_attribute_assignments, :attribute_assignments
+			end
+
       def attr_defaults(attributes)
         @default_attributes = attributes
       end
@@ -193,6 +215,10 @@ module CSL
       !attributes.empty?
     end
 
+		def has_language?
+			false
+		end
+
     def textnode?
       false
     end
@@ -208,7 +234,7 @@ module CSL
 
     # Tests whether or not the Name matches the passed-in node name and
     # attribute conditions; if a Hash is passed as a single argument,
-    # it is taken as the conditions parameter (the name parameter is
+    # it is taken as the conditions parameter (the name parameter
     # automatically matches in this case).
     #
     # Whether or not the arguments match the node is determined as
@@ -225,6 +251,7 @@ module CSL
     #
     # @see #exact_match?
     #
+    # If the optional
     # @param name [String,Regexp] must match the nodename
     # @param conditions [Hash] the conditions
     #
@@ -276,6 +303,21 @@ module CSL
     end
     alias matches_exactly? exact_match?
 
+		# @option filter [Array] a list of attribute names
+		# @return [Hash] the node's attributes matching the filter
+		def attributes_for(*filter)
+			filter.flatten!
+
+			Hash[map { |name, value|
+				!value.nil? && filter.include?(name) ? [name, value.to_s] : nil
+			}.compact]
+		end
+
+		# @return [Hash] the node's formatting options
+		def formatting_options
+			attributes_for Schema.attr(:formatting)
+		end
+
     def <=>(other)
       [nodename, attributes, children] <=> [other.nodename, other.attributes, other.children]
     rescue
@@ -311,7 +353,7 @@ module CSL
 
     def attribute_assignments
       each_pair.map { |name, value|
-        value.nil? ? nil: [name, value.to_s.inspect].join('=')
+        value.nil? ? nil : [name, value.to_s.inspect].join('=')
       }.compact
     end
 

data/lib/csl/schema.rb

@@ -86,6 +86,10 @@ module CSL
     })
     
     @attributes.each_value { |v| v.map!(&:to_sym).freeze }
+
+		@attributes[:formatting] = [:'text-case'].concat(
+			@attributes.values_at(:affixes, :quotes, :font).flatten)
+
     @attributes.freeze
     
     @file = File.expand_path('../../../vendor/schema/csl.rng', __FILE__)

data/lib/csl/style/number.rb

@@ -4,7 +4,8 @@ module CSL
     class Number < Node
       attr_struct :variable, :form, :'text-case',
         *Schema.attr(:affixes, :display, :font)
-      
+
+      has_no_children
 
       # @return [Boolean] whether or not the number's format is set to
       #   :numeric; also returns true if the number's form attribute is not

data/lib/csl/style/text.rb

@@ -1,10 +1,12 @@
 module CSL
   class Style
-    
+
     class Text < Node
-      attr_struct :variable, :macro, :term, :form, :plural, :'text-case',
-        :value, *Schema.attr(:affixes, :display, :font, :quotes, :periods)
+      attr_struct :variable, :macro, :term, :form, :plural, :value,
+        *Schema.attr(:formatting, :display, :periods)
+
+      has_no_children
     end
-    
+
   end
 end