Add support for script subtag to Locale

Set Latn default script for sr

Author: inukshuk

lib/csl/locale.rb

@@ -15,7 +15,7 @@ class Locale < Node
     @extension = '.xml'.freeze
     @prefix = 'locales-'.freeze
 
-    @tag_pattern = /^[a-z]{2}(-[A-Z]{2})?|-[A-Z]{2}$/
+    @tag_pattern = /^[a-z]{2}(-[a-z]{4})?(-[a-z]{2})?|-[a-z]{2}$/i
 
     # Default languages/regions.
     # Auto-detection is based on these lists.
@@ -29,25 +29,30 @@ class Locale < Node
       AT de BR pt CA en CH de GB en TW zh
     }.map(&:to_sym)]).freeze
 
+    @scripts = Hash[*%w{
+      sr Latn
+    }.map(&:to_sym)].freeze
+
 
     class << self
       include Loader
 
       attr_accessor :default
-      attr_reader :languages, :regions
+      attr_reader :languages, :regions, :scripts
 
       def load(input = nil)
         input ||= Locale.default
         input = normalize input if input.to_s =~ @tag_pattern
         super(input)
       end
 
-      # Normalizes an IETF tag; adds a language's default region or a
-      # region's default language.
+      # Normalizes an IETF tag; adds default language, region, script.
       #
       # @example
       #   Locale.normalize("en")  #-> "en-US"
       #   Locale.normalize("-BR") #-> "pt-BR"
+      #   Locale.normalize("de-at") #-> "de-AT"
+      #   Locale.normalize("sr") #-> "sr-Latn-RS"
       #
       # @raise [ArgumentError] if the passed-in string is no IETF tag
       #
@@ -56,15 +61,32 @@ def load(input = nil)
       def normalize(tag)
         tag = tag.to_s.strip
 
-        raise ArgumentError, "not a valid IETF tag: #{tag.inspect}" unless
-          tag =~ @tag_pattern
+        unless tag =~ @tag_pattern
+          raise ArgumentError, "unsupported IETF tag: #{tag.inspect}"
+        end
+
+        language, *rs = tag.split(/-/)
+        region, script = rs.reverse
 
-        language, region = tag.split(/-/)
+        if language.nil? || language.empty?
+          language = languages[region.to_sym]
+        else
+          language.downcase!
+        end
 
-        return [language, regions[language.to_sym]].compact.join('-') if region.nil?
-        return [languages[region.to_sym], region].join('-') if language.empty?
+        if region.nil?
+          region = regions[language.to_sym]
+        else
+          region.upcase!
+        end
+
+        if script.nil?
+          script = scripts[language.to_sym]
+        else
+          script.capitalize!
+        end
 
-        tag
+        [language, script, region].compact.join('-')
       end
     end
 
@@ -78,7 +100,7 @@ def normalize(tag)
 
     has_language
 
-    attr_accessor :region
+    attr_accessor :region, :script
 
     alias_child :metadata, :info
     alias_child :dates, :date
@@ -181,14 +203,15 @@ def legacy?
     #
     # @return [self]
     def set(locale)
-      @language, @region = Locale.normalize(locale).split(/-/).map(&:to_sym)
+      @language, *rs = Locale.normalize(locale).split(/-/).map(&:to_sym)
+      @region, @script = rs.reverse
       self
     end
 
-    # Sets the locale's language and region to nil.
+    # Sets the locale's language, script and region to nil.
     # @return [self]
     def clear
-      @language, @region = nil
+      @language, @script, @region = nil
       self
     end
 
@@ -414,11 +437,12 @@ def reverse_merge(other)
     end
 
 
-    # Locales are sorted first by language, then by region; sort order is
-    # alphabetical with the following exceptions: the default locale is
-    # prioritised; in case of a language match the default region of that
-    # language will be prioritised (e.g., de-DE will come before de-AT even
-    # though the alphabetical order would be different).
+    # Locales are sorted first by language, then by region and script;
+    # sort order is alphabetical with the following exceptions:
+    # the default locale is prioritised; in case of a language match
+    # the default region of that language will be prioritised (e.g.,
+    # de-DE will come before de-AT even though the alphabetical order
+    # would be different).
     #
     # @param other [Locale] the locale used for comparison
     # @return [1,0,-1,nil] the result of the comparison
@@ -427,7 +451,7 @@ def <=>(other)
       when !other.is_a?(Locale)
         nil
       when [language, region] == [other.language, other.region]
-        0
+        script <=> other.script
       when default?
         -1
       when other.default?
@@ -448,7 +472,7 @@ def <=>(other)
 
     # @return [String] the Locale's IETF tag
     def to_s
-      [language, region].compact.join('-')
+      [language, script, region].compact.join('-')
     end
 
     # @return [String] a string representation of the Locale

spec/csl/locale_spec.rb

@@ -37,7 +37,13 @@ module CSL
         'en' => 'en-US',
         '-GB' => 'en-GB',
         '-BR' => 'pt-BR',
-        'de-AT' => 'de-AT'
+        'de-AT' => 'de-AT',
+        'de-aT' => 'de-AT',
+        'sr-RS' => 'sr-Latn-RS',
+        'sr' => 'sr-Latn-RS',
+        '-RS' => 'sr-Latn-RS',
+        'sr-latn-rs' => 'sr-Latn-RS',
+        'sr-Cyrl-RS' => 'sr-Cyrl-RS'
       }.each_pair do |tag, expected|
         it "converts #{tag.inspect} to #{expected.inspect}" do
           expect(Locale.normalize(tag)).to eq(expected)
@@ -56,6 +62,10 @@ module CSL
         expect(Locale.new.region).to be_nil
       end
 
+      it 'has no script' do
+        expect(Locale.new.script).to be_nil
+      end
+
       it 'contains no dates by default' do
         expect(Locale.new.dates).to be_nil
       end
@@ -94,22 +104,25 @@ module CSL
     end
 
     describe '#set' do
-
       it 'when passed "en-GB" sets language to :en and region to :GB' do
         locale.set('en-GB')
-        expect([locale.language, locale.region]).to eq([:en, :GB])
+        expect([locale.language, locale.region, locale.script]).to eq([:en, :GB, nil])
       end
 
       it 'when passed "de" sets language to :de and region to :DE' do
         locale.set('de')
-        expect([locale.language, locale.region]).to eq([:de, :DE])
+        expect([locale.language, locale.region, locale.script]).to eq([:de, :DE, nil])
       end
 
       it 'when passed "-AT" sets language to :de and region to :AT' do
         locale.set('-AT')
-        expect([locale.language, locale.region]).to eq([:de, :AT])
+        expect([locale.language, locale.region, locale.script]).to eq([:de, :AT, nil])
       end
 
+      it 'when passed "sr" sets language, region, and script' do
+        locale.set('sr')
+        expect([locale.language, locale.region, locale.script]).to eq([:sr, :RS, :Latn])
+      end
     end
 
     describe '#merge!' do