locale 0.9.0

data/lib/locale/info.rb

@@ -0,0 +1,12 @@
+=begin
+
+ info.rb - Load Locale::Info::Language and Locale::Info::Region.
+
+ Copyright (C) 2008  Masao Mutoh
+ 
+ $Id: info.rb 27 2008-12-03 15:06:50Z mutoh $
+=end
+
+require 'locale/info/language'
+require 'locale/info/region'
+

data/lib/locale/info/language.rb

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+=begin
+
+ language.rb - Locale::Info::Language class
+
+ Copyright (C) 2008  Masao Mutoh
+ 
+ Original Author:: Brian Pontarelli
+
+ $Id: language.rb 27 2008-12-03 15:06:50Z mutoh $
+=end
+
+require 'zlib'
+
+module Locale
+
+  module Info
+    # This class contains all the of the ISO information for the ISO 639-3
+    # languages. This class is immutable once constructed.
+    class Language
+      attr_reader :two_code, :three_code, :scope, :type, :name
+
+      #
+      # Constructs a new Language instance.
+      #
+      # * code  The 2 or 3 digit ISO 639-3 language code.
+      # * scope A single character that defines the ISO scope of the language - <tt>(I)ndividual</tt>,
+      #   <tt>(M)acrolanguage</tt>, or <tt>(S)pecial</tt>.
+      # * type   A single character that defines the ISO type of the language - <tt>(A)ncient</tt>,
+      #   <tt>(C)onstructed</tt>, <tt>(E)xtinct</tt>, <tt>(H)istorical</tt>, <tt>(L)iving</tt>,
+      #   or <tt>(S)pecial</tt>.
+      # * name  The name of the language.
+      #
+      def initialize(two_code, three_code, scope, type, name)
+        @two_code, @three_code, @scope, @type, @name = two_code, three_code, scope, type, name
+
+        @individual   = (scope == "I")
+        @macro        = (scope == "M")
+        @special      = (scope == "S")
+        @constructed  = (type == "C")
+        @living       = (type == "L")
+        @extinct      = (type == "E")
+        @ancient      = (type == "A")
+        @historical   = (type == "H")
+        @special_type = (type == "S")
+      end
+
+      # Returns true if the language is an individual language according to the ISO 639-3 data.
+      def individual?; @individual; end
+
+      # Returns true if the language is a macro language according to the ISO 639-3 data.
+      def macro?; @macro; end
+
+      # Returns true if the language is a special language according to the ISO 639-3 data.
+      def special?; @special; end
+
+      # Returns true if the language is a constructed language according to the ISO 639-3 data.
+      def constructed?; @constructed; end
+
+      # Returns true if the language is a living language according to the ISO 639-3 data.
+      def living?; @living; end
+
+      # Returns true if the language is an extinct language according to the ISO 639-3 data.
+      def extinct?; @extinct; end
+
+      # Returns true if the language is an ancient language according to the ISO 639-3 data.
+      def ancient?; @ancient; end
+
+      # Returns true if the language is an historical language according to the ISO 639-3 data.
+      def historical?; @historical; end
+
+      # Returns true if the language is a special type language according to the ISO 639-3 data.
+      def special_type?; @special_type; end
+
+      # Returns the two or three code.
+      def to_s
+        two_code || tree_code
+      end
+
+      # Returns this object is valid as ISO 639 data.
+      def iso_language?
+        @@lang_two_codes[two_code] != nil || @@lang_three_codes[three_code] != nil
+      end
+    end
+
+    @@lang_two_codes = Hash.new
+    @@lang_three_codes = Hash.new
+
+    Zlib::GzipReader.open(File.dirname(__FILE__) + "/../data/languages.tab.gz") do |gz|
+      gz.readlines.each do |l|
+        unless l =~ /^\s*$/
+          parts = l.split(/\t/)
+          lang = Language.new(parts[2], parts[0], parts[3], parts[4], parts[5].strip)
+          @@lang_three_codes[parts[0]] = lang
+          @@lang_two_codes[parts[2]] = lang if parts[2].length > 0
+        end
+      end
+    end
+
+    module_function
+
+    # Returns a hash of all the ISO languages. The hash is {String, language} where
+    # the string is the 3 digit language code from the ISO 639 data. This contains
+    # all of the data from the ISO 639-3 data (7600 Languages).
+    #
+    # Need to require 'locale/info' or 'locale/language'.
+    def three_languages
+      @@lang_three_codes
+    end
+
+    # Returns a hash of all the ISO languages. The hash is {String, language} where
+    # the string is the 2 digit language code from the ISO 639-1 data. This contains
+    # all of the data from the ISO 639-1 data (186 Languages).
+    #
+    # Need to require 'locale/info' or 'locale/language'.
+    def two_languages
+      @@lang_two_codes
+    end
+
+    # Returns the language for the given 2 or 3 digit code.
+    #
+    # Need to require 'locale/info' or 'locale/language'.
+    def get_language(code)
+      @@lang_three_codes[code] || @@lang_two_codes[code]
+    end
+
+    # Returns the language code is valid.
+    #
+    # Need to require 'locale/info' or 'locale/language'.
+    def language_code?(code)
+      get_language(code) != nil
+    end
+  end
+end

data/lib/locale/info/region.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+=begin
+
+ region.rb - Locale::Info::Region class
+
+ Copyright (C) 2008  Masao Mutoh
+ 
+ First Author:: Brian Pontarelli
+
+ $Id: region.rb 27 2008-12-03 15:06:50Z mutoh $
+=end
+
+require 'zlib'
+
+module Locale
+
+  module Info
+    # This class models out a region/country from the ISO 3166 standard for region codes.
+    # In ISO3166, it's called "Country" but Ruby/Locale the word "Region" instead.
+    class Region
+      attr_reader :code, :name
+
+      # code::  The 2 or 3 digit ISO 3166 region code.
+      # name::  The name of the region.
+      def initialize(code, name)
+        @code = code
+        @name = name
+      end
+
+      def iso_region?
+        @@regions[code] != nil
+      end
+
+      def to_s
+        "#{code}"
+      end
+    end
+
+    @@regions = Hash.new
+    Zlib::GzipReader.open(File.dirname(__FILE__) + "/../data/regions.tab.gz") do |gz|
+      gz.readlines.each do |l|
+        unless l =~ /^\s*$/
+          parts = l.split(/\t/)
+          region = Region.new(parts[0], parts[1].strip)
+          @@regions[parts[0]] = region
+        end
+      end
+    end
+
+    module_function
+
+    # Returns a hash of all the ISO regions. The hash is {String, Region} where
+    # the string is the 2 digit region code from the ISO 3166 data.
+    #
+    # You need to require 'locale/info' or 'locale/region'.
+    def regions
+      @@regions
+    end
+
+    # Returns the region for the given code.
+    #
+    # You need to require 'locale/info' or 'locale/info/region'.
+    def get_region(code)
+      @@regions[code]
+    end
+
+    # Returns the region code is valid.
+    #
+    # You need to require 'locale/info' or 'locale/info/region'.
+    def valid_region_code?(code)
+      @@regions[code] != nil
+    end
+  end
+end

data/lib/locale/tag.rb

@@ -0,0 +1,36 @@
+=begin
+
+ tag.rb - Locale::Tag module
+
+ Copyright (C) 2008  Masao Mutoh
+ 
+ $Id: tag.rb 27 2008-12-03 15:06:50Z mutoh $
+=end
+
+require 'locale/tag/simple'
+require 'locale/tag/illegular'
+require 'locale/tag/common'
+require 'locale/tag/rfc'
+require 'locale/tag/cldr'
+require 'locale/tag/posix'
+
+module Locale
+
+  # Language tag / locale identifiers.
+  module Tag
+    module_function
+    # Parse a language tag/locale name and return Locale::Tag
+    # object.
+    # * tag: a tag as a String. e.g.) ja-Hira-JP
+    # * Returns: a Locale::Tag subclass.
+    def parse(tag)
+      # Common is not used here.
+      [Simple, Common, Rfc, Cldr, Posix].each do |parser|
+        ret = parser.parse(tag)
+        return ret if ret
+      end
+      Locale::Tag::Illegular.new(tag)
+    end
+  end
+end
+

data/lib/locale/tag/cldr.rb

@@ -0,0 +1,93 @@
+=begin
+  locale/tag/cldr.rb - Locale::Tag::CLDR
+
+  Copyright (C) 2008  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: cldr.rb 27 2008-12-03 15:06:50Z mutoh $
+=end
+
+module Locale #:nodoc:
+  module Tag #:nodoc:
+
+    # Unicode locale identifier class for CLDR-1.6.1.
+    # (Unicode Common Locale Data Repository).
+    class Cldr < Common
+
+      VARIANT = "(#{ALPHANUM}{5,8}|#{DIGIT}#{ALPHANUM}{3})" 
+      EXTENSION = "#{ALPHANUM}+=[a-z0-9\-]+"
+
+      TAG_RE = /\A#{LANGUAGE}(?:[-_]#{SCRIPT})?
+                  (?:[-_]#{REGION})?((?:[-_]#{VARIANT})*
+                  (?:@(#{EXTENSION};?)+)*)\Z/ix
+
+      attr_reader :extensions
+ 
+      # Create Locale::Tag::Cldr.
+      #
+      # variants should be upcase.
+      def initialize(language, script = nil, region = nil, 
+                     variants = [], extensions = {})
+        @extensions = extensions
+        super(language, script, region, variants.map{|v| v.upcase})
+      end
+
+      # Parse the language tag and return the new Locale::Tag::CLDR. 
+      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 = {}
+          subtag.scan(/#{EXTENSION}/i).each{|v| 
+            subtag.sub!(v, "")
+            key, type = v.split("=")
+            extensions[key] = type
+          }
+          variants = subtag.scan(/#{VARIANT}/i).collect{|v| v[0].upcase}
+
+          ret = self.new(lang, script, region, variants, extensions)
+          ret.tag = tag
+          ret
+        else
+          nil
+        end
+      end
+
+      # Returns the language tag. 
+      # (e.g.) "ja_Hira_JP_VARIANT1_VARIANT2@foo1=var1;foo2=var2"
+      def to_s
+        s = super
+        if @extensions.size > 0
+          s << "@" << @extensions.to_a.sort.map{|k, v| "#{k}=#{v}"}.join(";")
+        end
+        s
+      end
+
+      # Sets the extensions.
+      def extensions=(val)
+        clear
+        @extensions = val
+      end
+
+      private
+      def convert_to(klass)
+        if klass == Cldr
+          klass.new(language, script, region, variants, extensions)
+        elsif klass == Rfc
+          exts = []
+          @extensions.each do |k, v|
+            exts << "k-#{k[0,8]}-#{v[0,8]}"
+          end
+
+          klass.new(language, script, region, variants, exts)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/locale/tag/common.rb

@@ -0,0 +1,122 @@
+=begin
+  locale/tag/common.rb - Locale::Tag::Common
+
+  Copyright (C) 2008  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: common.rb 27 2008-12-03 15:06:50Z mutoh $
+=end
+
+module Locale
+  module Tag
+    # Common Language tag class for Ruby.
+    # Java and MS Windows use this format. 
+    #
+    # * ja (language: RFC4646)
+    # * ja_JP (country: RFC4646(2 alpha or 3 digit))
+    # * ja-JP
+    # * ja_Hira_JP (script: 4 characters)
+    # * ja-Hira-JP
+    # * ja_Hira_JP_MOBILE (variants: more than 2 characters or 3 digit)
+    # * ja_Hira_JP_MOBILE_IPHONE (2 variants example)
+    #
+    class Common < Simple
+      LANGUAGE = "(#{ALPHA}{2,3}|#{ALPHA}{4}|#{ALPHA}{5,8})" #RFC4646 (ISO639/reserved/registered)
+      SCRIPT = "(#{ALPHA}{4})"
+      VARIANT = "(#{ALPHANUM}{3,}|#{DIGIT}#{ALPHANUM}{3})"   #RFC3066 compatible
+
+      TAG_RE = /\A#{LANGUAGE}(?:[-_]#{SCRIPT})?
+                  (?:[-_]#{REGION})?((?:[-_]#{VARIANT})*)\Z/ix
+
+      attr_reader :script, :variants
+
+      # Create a Locale::Tag::Common.
+      def initialize(language, script = nil, region = nil, variants = [])
+        @script, @variants = script, variants
+        @script.capitalize!  if @script
+        super(language, region)
+      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
+          variants = subtag.scan(/(^|[-_])#{VARIANT}(?=([-_]|$))/i).collect{|v| v[1]}
+
+          ret = self.new(lang, script, region, variants)
+          ret.tag = tag
+          ret
+        else
+          nil
+        end
+      end
+
+      # Set the script (with capitalize)
+      def script=(val)
+        clear
+        @script = val
+        @script.capitalize! if @script
+        @script
+      end
+
+      # Set the variants
+      def variants=(val)
+        clear
+        @variants = val
+      end
+
+      # Returns the common language tag with "_".
+      #   <language>_<Script>_<REGION>_VARIANTS1_VARIANTS2
+      #   (e.g.) "ja_Hira_JP_VARIANTS1_VARIANTS2"
+      def to_s
+        s = @language.dup
+    
+        s << "_" << @script if @script
+        s << "_" << @region if @region
+
+        @variants.each do |v|
+          s << "_#{v}"
+        end
+        s
+      end
+
+      # Returns an Array of tag-candidates order by priority.
+      # Use Locale.candidates instead of this method.
+      #
+      # Locale::Tag::Rfc, Cldr don't have their own candidates,
+      # because it's meaningless to compare the extensions, privateuse, etc.
+      def candidates
+        [self.class.new(language, script, region, variants),   #ja-Kana-JP-FOO
+         self.class.new(language, script, region),             #ja-Kana-JP
+         self.class.new(language, nil, region, variants),      #ja-JP-FOO
+         self.class.new(language, nil, region),                #ja-JP
+         self.class.new(language, script, nil, variants),      #ja-Kana-FOO
+         self.class.new(language, script),                     #ja-Kana
+         self.class.new(language, nil, nil, variants),         #ja-FOO
+         self.class.new(language)]                             #ja
+      end
+
+      private
+      def convert_to(klass)
+        if klass == Simple
+          super
+        elsif klass == Posix
+          if variants.size > 0 
+            var = variants.join("-") 
+          else
+            var = nil
+          end
+          klass.new(language, region, nil, var)
+        elsif klass == Cldr
+          klass.new(language, script, region, variants.map{|v| v.upcase})
+        else
+          klass.new(language, script, region, variants)
+        end
+      end
+    end
+  end
+end