module CSL # # CSL::Locales contain locale specific date formatting options, term # translations, and a number ordinalizer. # class Locale < Node types << CSL::Info include Comparable @default = 'en-US'.freeze @root = '/usr/local/share/csl/locales'.freeze @extension = '.xml'.freeze @prefix = 'locales-'.freeze @tag_pattern = /^[a-z]{2}(-[A-Z]{2})?|-[A-Z]{2}$/ # Default languages/regions. # Auto-detection is based on these lists. @regions = Hash[*%w{ af ZA bg BG ca AD cs CZ da DK de DE el GR en US es ES et EE fa IR fr FR he IL hu HU is IS it IT ja JP km KH ko KR mn MN nb NO nl NL nn NO pl PL pt PT ro RO ru RU sk SK sl SI sr RS sv SE th TH tr TR uk UA vi VN zh CN }.map(&:to_sym)].freeze @languages = @regions.invert.merge(Hash[*%w{ AT de BR pt CA en CH de GB en TW zh }.map(&:to_sym)]).freeze class << self include Loader attr_accessor :default attr_reader :languages, :regions 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. # # @example # Locale.normalize("en") #-> "en-US" # Locale.normalize("-BR") #-> "pt-BR" # # @raise [ArgumentError] if the passed-in string is no IETF tag # # @param tag [String] an IETF tag to be normalized # @return [String] the normalized IETF tag def normalize(tag) tag = tag.to_s.strip raise ArgumentError, "not a valid IETF tag: #{tag.inspect}" unless tag =~ @tag_pattern language, region = tag.split(/-/) return [language, regions[language.to_sym]].compact.join('-') if region.nil? return [languages[region.to_sym], region].join('-') if language.empty? tag end end attr_defaults :version => Schema.major_version, :xmlns => Schema.namespace show_default_attributes! attr_struct :xmlns, :version attr_children :info, :'style-options', :date, :terms has_language attr_accessor :region alias_child :metadata, :info alias_child :dates, :date alias_child :options, :style_options protected :attributes undef_method :[]= # @example # Locale.new #-> default # Locale.new('en') #-> American English # Locale.new('en', :'punctuation-in-quote' => false) #-> with style-options # Locale.new(:lang => 'en-GB', :version => '1.0') #-> British English # # Returns a new locale. In the first form, the language/regions is set # to the default language and region. In the second form the # language/region is set by the passed-in IETF tag. The third form # additionally accepts a hash of localize style-options. The fourth form # is the standard node attribute initialize signature. def initialize(*arguments) case arguments.length when 0 locale, attributes, options = Locale.default, {}, nil when 1 if arguments[0].is_a?(Hash) arguments[0] = arguments[0].symbolize_keys locale = arguments[0].delete(:lang) || arguments[0].delete(:'xml:lang') || Locale.default attributes, options = arguments else attributes, locale, options = {}, *arguments end when 2 attributes, locale, options = {}, *arguments else raise ArgumentError, "wrong number of arguments (#{arguments.length} for 0..2)" end super(attributes, &nil) set(locale) unless locale.nil? unless options.nil? children[:'style-options'] = StyleOptions.new(options) end yield self if block_given? end def initialize_copy(other) @parent, @ancestors, @descendants, @siblings, @root, @depth = nil initialize(other.attributes.to_hash.merge(:lang => other.to_s)) end def added_to(node) raise ValidationError, "not allowed to add locale to #{node.nodename}" unless node.nodename == 'style' end def version attributes[:version] end def version=(version) raise ArgumentError, "failed to set version to #{version}" unless version.respond_to?(:to_s) version = version.to_s.strip raise ArgumentError, "failed to set version to #{version}: not a version string" unless version =~ /^\d[\d\.]+$/ if version > Schema.version warn "setting version to #{version}; latest supported version is #{Schema.version}" end attributes[:version] = version end # @return [Boolean] whether or not the Locale's version is less than CSL-Ruby's default version def legacy? version < Schema.major_version end # @example # locale.set('en') #-> sets language to :en, region to :US # locale.set('de-AT') #-> sets language to :de, region to :AT # locale.set('-DE') #-> sets langauge to :de, region to :DE # # Sets language and region according to the passed-in locale string. If # the region part is not defined by the string, this method will set the # region to the default region for the given language. # # @raise [ArgumentError] if the argument is no valid locale string. # A valid locale string is based on the syntax of IETF language tags; # it consists of either a language or region tag (or both), separated # by a hyphen. # # @return [self] def set(locale) @language, @region = Locale.normalize(locale).split(/-/).map(&:to_sym) self end # Sets the locale's language and region to nil. # @return [self] def clear @language, @region = nil self end # @return [String, nil] the term's translation def translate(name, options = {}) return unless has_terms? term = terms.lookup name, options term && term.to_s(options) end alias t translate # Stores a translation in the locale's term registry. # @see Terms#store def store(*arguments) unless has_terms? self << CSL::Locale::Terms.new end terms.store(*arguments) self end alias learn store # 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 = number.to_i ordinal = terms.ordinalize number, options return number.to_s if ordinal.nil? return ordinal.to_s(options) if ordinal.long_ordinal? [number, ordinal.to_s(options)].join end # @return [Boolean] true when the option limit-day-ordinals-to-day-1 is true def limit_day_ordinals? return false unless has_options? && options.attribute?(:'limit-day-ordinals-to-day-1') !!(options[:'limit-day-ordinals-to-day-1'].to_s =~ /^true$/i) end def limit_day_ordinals! unless has_options? children[:'style-options'] = StyleOptions.new end options[:'limit-day-ordinals-to-day-1'] = true end # @return [Boolean] true when the option punctuation-in-quote is true def punctuation_in_quote? return false unless has_options? && options.attribute?(:'punctuation-in-quote') !!(options[:'punctuation-in-quote'].to_s =~ /^true$/i) end alias punctuation_in_quotes? punctuation_in_quote? def punctuation_in_quote! unless has_options? children[:'style-options'] = StyleOptions.new end options[:'punctuation-in-quote'] = true end alias punctuation_in_quotes! punctuation_in_quote! # Puts localized quotes around the passed-in string. # @return [String] the quoted string def quote(string, escape = false) oq, cq = t('open-quote'), t('close-quote') return string if oq.nil? || cq.nil? || (oq.empty? && cq.empty?) if escape oq = CSL.encode_xml_text(oq) cq = CSL.encode_xml_text(cq) end string = replace_with_inner_quotes(string, oq, cq, escape) if punctuation_in_quotes? "#{oq}#{string}#{cq}" else string, punctuation = string.split(/([\.,])$/, 2) "#{oq}#{string}#{cq}#{punctuation}" end end def replace_with_inner_quotes(string, open, close, escape = false) oq, cq = t('open-inner-quote'), t('close-inner-quote') return string if oq.nil? || cq.nil? || (oq.empty? && cq.empty?) if escape oq = CSL.encode_xml_text(oq) cq = CSL.encode_xml_text(cq) end string.gsub(/(#{open}|"\b)/, oq).gsub(/(#{close}|\b")/, cq) end # @example # locale.each_term { |term| block } #-> locale # locale.each_term #-> enumerator # # Calls block once for each term defined by the locale. If no block is # given, an enumerator is returned instead. def each_term if block_given? terms.each(&Proc.new) self else enum_for :each_term end end # @example # locale.each_date { |date_format| block } #-> locale # locale.each_date #-> enumerator # # Calls block once for each date format defined by the locale. If no # block is given, an enumerator is returned instead. def each_date if block_given? date.each(&Proc.new) else enum_for :each_date end end # @returns [Boolean] whether or not the Locale is the default locale def default? to_s == Locale.default end # @return [Boolean] whehter or not the Locale's region is the default # region for its language def default_region? region && region == Locale.regions[language] end # @return [Boolean] whether or not the Locale's language is the default # language for its region def default_language? language && language == Locale.languages[region] end def validate Schema.validate self end def valid? validate.empty? end # @return [Locale] def merge(*others) deep_copy.merge!(*others) end # @return [self] def merge!(*others) others.each do |other| merge_options other merge_dates other end self 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). # # @param other [Locale] the locale used for comparison # @return [1,0,-1,nil] the result of the comparison def <=>(other) case when !other.is_a?(Locale) nil when [language, region] == [other.language, other.region] 0 when default? -1 when other.default? 1 when language == other.language case when default_region? -1 when other.default_region? 1 else region <=> other.region end else language <=> other.language end end # @return [String] the Locale's IETF tag def to_s [language, region].compact.join('-') end # @return [String] a string representation of the Locale def inspect "#<#{self.class.name} #{to_s}>" end private alias original_locale_attribute_assignments attribute_assignments def attribute_assignments if root? original_locale_attribute_assignments else 'xml:lang="%s"' % to_s end end def preamble Schema.preamble.dup end # @param other [Locale] an other locale whose options should be merged # @return [self] def merge_options(other) return self unless other.has_options? if has_options? options.attributes.merge! other.options.attributes else add_child other.options.dup end self end # @param other [Locale] an other locale whose date nodes should be merged # @return [self] def merge_dates(other) return self unless other.has_dates? if has_dates? other.each_date do |date| delete_children each_date.select { |d| d[:form] == date[:form] } add_child date.deep_copy end else other.each_date do |date| add_child date.deep_copy end end self end end end