locale 0.9.0

data/lib/locale/tag/illegular.rb

@@ -0,0 +1,38 @@
+=begin
+  locale/tag/illegular.rb - Locale::Tag::Illegular
+
+  Copyright (C) 2008  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: illegular.rb 27 2008-12-03 15:06:50Z mutoh $
+=end
+
+require 'locale/tag/simple'
+
+module Locale
+
+  module Tag
+    # Broken tag class.
+    class Illegular < Simple
+
+      def initialize(tag)
+        tag = "en" if tag == nil || tag.empty?
+        @language = tag
+        @tag = tag
+      end
+
+      # Returns an Array of tag-candidates order by priority.
+      def candidates
+        [Illegular.new(tag)]
+      end
+
+      # Conver to the klass(the class of Language::Tag)
+      private
+      def convert_to(klass)
+        klass.new(tag)
+      end
+    end
+  end
+end

data/lib/locale/tag/posix.rb

@@ -0,0 +1,97 @@
+=begin
+  locale/tag/posix.rb - Locale::Tag::Posix
+
+  Copyright (C) 2008  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: posix.rb 27 2008-12-03 15:06:50Z mutoh $
+=end
+
+module Locale #:nodoc:
+  module Tag #:nodoc:
+
+    # Locale tag class for POSIX locale
+    # * ja
+    # * ja_JP
+    # * ja_JP.UTF-8
+    # * ja_JP.UTF-8@Osaka
+    # * C/POSIX (-> en_US)
+    class Posix < Simple
+      LANGUAGE = "([a-z]{2,})"
+      TAG_RE = /\A#{LANGUAGE}(?:_#{REGION})?(?:\.([^@]+))?(?:@(.*))?\Z/i
+
+      attr_reader :charset, :modifier
+
+      def initialize(language, region = nil, charset = nil, modifier = nil)
+        @charset, @modifier = charset, modifier
+        super(language, region)
+      end
+
+      def self.parse(tag)
+        if tag =~ /^(C|POSIX)$/
+          ret = self.new("en", "US")
+          ret.tag = tag
+          ret
+        elsif tag =~ TAG_RE
+          ret = self.new($1, $2, $3, $4)
+          ret.tag = tag
+          ret
+        else
+          nil
+        end
+      end
+
+      # Returns the language tag. 
+      #   <language>_<COUNTRY>.<CHARSET>@<MODIFIER>
+      #   (e.g.) "ja_JP.EUC-JP@Modifier"
+      def to_s
+        s = @language.dup
+        s << "_#{@region}" if @region
+        s << ".#{@charset}" if @charset
+        s << "@#{@modifier}" if @modifier
+        s
+      end
+
+      # Set the charset.
+      def charset=(val)
+        clear
+        @charset = val
+      end
+
+      # Set the modifier.
+      def modifier=(val)
+        clear
+        @modifier = val
+      end
+
+      # Returns an Array of tag-candidates order by priority.
+      # Use Locale.candidates instead of this method.
+      def candidates
+        [self.class.new(language, region, charset, modifier),  #ja_JP.UTF-8@Modifier
+         self.class.new(language, region, charset),            #ja_JP.UTF-8
+         self.class.new(language, region, nil, modifier),      #ja_JP@Modifier
+         self.class.new(language, region, nil, nil),           #ja_JP@Modifier
+         self.class.new(language, nil, charset, modifier),     #ja.UTF-8@Modifier
+         self.class.new(language, nil, charset),               #ja.UTF-8
+         self.class.new(language, nil, nil, modifier),         #ja@Modifier
+         self.class.new(language)]                             #ja
+      end
+
+      # A modifier is converted to a variant.
+      # If the modifier is less than 5 characters, it is not canonical value.
+      private
+      def convert_to(klass)
+        if klass == Simple
+          super
+        elsif klass == Posix
+          klass.new(language, region, charset, modifier)
+        else
+          klass.new(language, nil, region, modifier ? [modifier] : [])
+        end
+      end
+
+    end
+  end
+end

data/lib/locale/tag/rfc.rb

@@ -0,0 +1,106 @@
+=begin
+  locale/tag/rfc.rb - Locale::Tag::Rfc
+
+  Copyright (C) 2008  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: rfc.rb 27 2008-12-03 15:06:50Z mutoh $
+=end
+
+module Locale #:nodoc:
+  module Tag #:nodoc:
+
+    # Language tag class for RFC4646(BCP47).
+    class Rfc < Common
+      SINGLETON = '[a-wyz0-9]'
+      VARIANT = "(#{ALPHANUM}{5,8}|#{DIGIT}#{ALPHANUM}{3})" 
+      EXTENSION = "(#{SINGLETON}(?:-#{ALPHANUM}{2,8})+)"
+      PRIVATEUSE = "(x(?:-#{ALPHANUM}{1,8})+)"
+      GRANDFATHERED = "#{ALPHA}{1,3}(?:-#{ALPHANUM}{2,8}){1,2}"
+      
+      TAG_RE = /\A#{LANGUAGE}(?:-#{SCRIPT})?
+                  (?:-#{REGION})?((?:-#{VARIANT})*
+                  (?:-#{EXTENSION})*(?:-#{PRIVATEUSE})?)\Z/ix
+
+      attr_reader :extensions, :privateuse
+
+      def initialize(language, script = nil, region = nil, variants = [],
+                     extensions = [], privateuse = nil)
+        @extensions, @privateuse = extensions, privateuse
+        super(language, script, region, variants)
+      end
+
+      # Parse the language tag and return the new Locale::Tag::Common. 
+      def self.parse(tag)
+        if tag =~ /\APOSIX\Z/  # This is the special case of POSIX locale but match this regexp.
+          nil
+        elsif tag =~ TAG_RE
+          lang, script, region, subtag = $1, $2, $3, $4
+          extensions = []
+          variants = []
+          if subtag =~ /#{PRIVATEUSE}/
+            subtag, privateuse = $`, $1
+            # Private use for CLDR.
+            if /x-ldml(.*)/ =~ privateuse
+              p_subtag = $1 
+              extensions = p_subtag.scan(/(^|-)#{EXTENSION}/i).collect{|v| p_subtag.sub!(v[1], ""); v[1]}
+              variants = p_subtag.scan(/(^|-)#{VARIANT}(?=(-|$))/i).collect{|v| v[1]}
+            end
+          end
+          extensions += subtag.scan(/(^|-)#{EXTENSION}/i).collect{|v| subtag.sub!(v[1], ""); v[1]}
+          variants += subtag.scan(/(^|-)#{VARIANT}(?=(-|$))/i).collect{|v| v[1]}
+          
+          ret = self.new(lang, script, region, variants, extensions, privateuse)
+          ret.tag = tag
+          ret
+        else
+          nil
+        end
+      end
+
+      # Returns the language tag 
+      #   <language>-<Script>-<REGION>-<variants>-<extensions>-<PRIVATEUSE>
+      #   (e.g.) "ja-Hira-JP-variant"
+      def to_s
+        s = super.to_s.gsub(/_/, "-")
+        @extensions.each do |v|
+          s << "-#{v}"
+        end
+        s << "-#{@privateuse}" if @privateuse
+        s
+      end
+
+      # Sets the extensions.
+      def extensions=(val)
+        clear
+        @extensions = val
+      end
+
+      # Sets the extensions.
+      def privateuse=(val)
+        clear
+        @privateuse = val
+      end
+
+      private
+      def convert_to(klass)
+        if klass == Rfc
+          klass.new(language, script, region, variants, extensions, privateuse)
+        elsif klass == Cldr
+          exts = {}
+          extensions.each do |v|
+            if v =~ /^k-(#{ALPHANUM}{2,})-(.*)$/i
+              exts[$1] = $2
+            end
+          end
+          klass.new(language, script, region, variants, exts)
+        else
+          super
+        end
+      end
+      
+    end
+  end
+end

data/lib/locale/tag/simple.rb

@@ -0,0 +1,145 @@
+=begin
+  locale/tag/simple.rb - Locale::Tag::Simple
+
+  Copyright (C) 2008  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: simple.rb 27 2008-12-03 15:06:50Z mutoh $
+=end
+
+require 'locale/util/memoizable'
+
+module Locale
+  module Tag
+    # Abstract language tag class.
+    # This class has <language>, <region> which
+    # all of language tag specifications have.
+    #
+    # * ja (language: ISO 639 (2 or 3 alpha))
+    # * ja_JP (country: RFC4646 (ISO3166/UN M.49) (2 alpha or 3 digit)
+    # * ja-JP
+    # * ja-392
+    class Simple
+      ALPHA = '[a-z]'
+      DIGIT = '[0-9]'
+      ALPHANUM = "[a-zA-Z0-9]"
+
+      LANGUAGE = "(#{ALPHA}{2,3})" # ISO 639
+      REGION = "(#{ALPHA}{2}|#{DIGIT}{3})"   # RFC4646 (ISO3166/UN M.49)
+
+      TAG_RE = /\A#{LANGUAGE}(?:[_-]#{REGION})?\Z/i
+
+      include Util::Memoizable
+
+      attr_reader :language, :region
+
+      # tag is set when .parse method is called.
+      # This value is used when the program want to know the original
+      # String.
+      attr_accessor :tag
+
+      # Parse the language tag and return the new Locale::Tag::Simple. 
+      def self.parse(tag)
+        if tag =~ TAG_RE
+          ret = self.new($1, $2)
+          ret.tag = tag
+          ret
+        else
+          nil
+        end
+      end
+
+      # call-seq:
+      # to_common
+      # to_posix
+      # to_rfc
+      # to_cldr
+      #
+      # Convert to each tag classes.
+      [:simple, :common, :posix, :rfc, :cldr].each do |name|
+        class_eval <<-EOS
+          def to_#{name}
+            convert_to(#{name.to_s.capitalize})
+          end
+          memoize :to_#{name}
+        EOS
+      end
+        
+      # Create a Locale::Tag::Simple
+      def initialize(language, region = nil)
+        raise "language can't be nil." unless language
+        @language, @region = language, region
+        @language.downcase! if @language
+        @region.upcase! if @region
+      end
+
+      # Returns the language tag as the String. 
+      #   <language>_<REGION>
+      #   (e.g.) "ja_JP"
+      def to_s
+        s = @language.dup
+        s << "_" << @region if @region
+        s
+      end
+
+      def to_str  #:nodoc:
+        to_s
+      end
+
+      def ==(other)  #:nodoc:
+        other != nil and hash == other.hash
+      end
+      
+      def eql?(other) #:nodoc:
+        self.==(other)
+      end
+      
+      def hash #:nodoc:
+        "#{self.class}:#{to_s}".hash
+      end
+
+      def inspect  #:nodoc:
+        %Q[#<#{self.class}: #{to_s}>]
+      end
+
+      # For backward compatibility.
+      def country; region end
+
+      # Set the language (with downcase)
+      def language=(val)
+        clear
+        @language = val
+        @language.downcase! if @language
+        @language
+      end
+
+      # Set the region (with upcase)
+      def region=(val)
+        clear
+        @region = val
+        @region.upcase! if @region
+        @region
+      end
+
+      # Returns an Array of tag-candidates order by priority.
+      # Use Locale.candidates instead of this method.
+      def candidates
+        [self.class.new(language, region), self.class.new(language)]
+      end
+
+      memoize :to_s, :to_str, :hash, :inspect, :candidates
+
+      # Conver to the klass(the class of Language::Tag)
+      private
+      def convert_to(klass)
+        if klass == Simple || klass == Posix
+          klass.new(language, region)
+        else
+          klass.new(language, nil, region)
+        end
+      end
+    end
+  end
+end

data/lib/locale/taglist.rb

@@ -0,0 +1,93 @@
+=begin
+  taglist.rb - Locale module
+
+  Copyright (C) 2008  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: taglist.rb 27 2008-12-03 15:06:50Z mutoh $
+=end
+
+module Locale
+  # This provides the subclass of Array which behaves like 
+  # the first(top priority) Locale::Tag object. 
+  # "Locale.current.language" is same with "Locale.current[0].language".
+  #
+  # Locale.current returns an Array of Tag(s) now.
+  # But the old Locale.current(Ruby-GetText) and Locale.get 
+  # returns Locale::Object (similier with Locale::Tag::Posix). 
+  # This is the class for backward compatibility.
+  #
+  # It is recommanded to use Locale.current[0] or 
+  # Locale.candidates to find the current locale instead
+  # of this function.
+  #
+  class TagList < Array 
+    # Returns the top priority language. (simple)
+    def language
+      self[0].language
+    end
+    # Returns the top priority region/country. (simple)
+    def country
+      self[0].region
+    end
+    # Returns the top priority region/country. (simple)
+    def region
+      self[0].region
+    end
+    # Returns the top priority script. (common)
+    def script
+      self[0].script
+    end
+    # Returns the top priority charset. (posix)
+    def charset
+      if self[0].respond_to? :charset
+        self[0].charset
+      else
+        ::Locale.driver_module.charset
+      end
+    end
+    # Returns the top priority modifier. (posix)
+    def modifier
+      (self[0].respond_to? :modifier) ? self[0].modifier : nil
+    end
+    # Returns the top priority extensions.(common, rfc, cldr)
+    def extensions
+      (self[0].respond_to? :extensions) ? self[0].extensions : nil
+    end
+    # Returns the top priority privateuse(rfc)
+    def privateuse
+      (self[0].respond_to? :privateuse) ? self[0].privateuse : nil
+    end
+
+    def to_str
+      self[0].to_str
+    end
+
+    def to_s
+      self[0].to_s
+    end
+    
+    def to_common
+      self[0].to_common
+    end
+
+    def to_simple
+      self[0].to_simple
+    end
+
+    def to_rfc
+      self[0].to_rfc
+    end
+
+    def to_cldr
+      self[0].to_cldr
+    end
+
+    def to_posix
+      self[0].to_posix
+    end
+
+  end
+end