twitter_cldr 6.6.2 → 6.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86de4e3cfb05e54b776d518c6a4c6decb9aaa36ec36ae2593e487cb12d7299ad
-  data.tar.gz: 8abd9399b1d44d30cd2cf818ef2c881b8dace4cf042b33e8a6086b02b5a0b561
+  metadata.gz: ce23d1d3e7d5428401b92b60c2570f8a2370e41beb32068fc0df7a6ce4959126
+  data.tar.gz: 595d913024e24dd3fd86426f12288c7040904f446291145e5ba92c0945a33d12
 SHA512:
-  metadata.gz: 57f9bb2095d152659a1a34f9a1c565496ddc6ac00cf5148f322709b5236d2c201502d7b9988e8ef7373ecff507b8fac944423d2c9a18dc8e65613fee9faf7440
-  data.tar.gz: 646cf95c956f2fa9655d4b96be566f4b59d18e5665ffe4bf04af3470aa0a75a9dbe1e163c74ed448eebed2b37ea98cd7e6c1b431e0b12c602a12a6cc47c438e4
+  metadata.gz: 402c8198faf70a1f72631e202278e2bf464a67c81d42dec357f0c474d078085054651b2bd166e1de6c1d078c83ddfbcc757de638affb3415e597d6283033465e
+  data.tar.gz: d06ad1e4fc3aac7d069d606b75c1bcde9261f53805d9441914a042a641ed83cd0e06caa8039e7f44308726f686cc02ebeb0aeda52a693d5dbbbd9da3c0b46694

data/Gemfile

@@ -4,7 +4,7 @@ gemspec
 
 group :development, :test do
   gem 'rake'
-  gem 'pry-byebug'
+  gem 'pry-byebug' unless RUBY_PLATFORM == 'java'
   gem 'ruby-prof' unless RUBY_PLATFORM == 'java'
   gem 'regexp_parser', '~> 0.5'
   gem 'benchmark-ips'
@@ -13,7 +13,7 @@ group :development, :test do
   # gemspec allows any version, but most people are probably using 1.x, so
   # let's test and develop against that
   gem 'tzinfo', '< 2'
-  gem 'tzinfo-data', '= 1.2020.4'  # keep in sync with ICU
+  gem 'tzinfo-data', '= 1.2021.1'  # try to keep in sync with ICU
 end
 
 group :development do

data/README.md

@@ -92,7 +92,7 @@ TwitterCLDR supports formatting numbers with an attached unit, for example "12 d
 
 ```ruby
 12.localize.to_unit.length_mile  # "12 miles"
-12.localize(:ru).to_unit.length_mile  # "12 миль"
+12.localize(:ru).to_unit.length_mile  # "12 милях"
 ```
 Units support a few different forms, long, short, and narrow:
 
@@ -177,8 +177,8 @@ For English (and other languages), you can also specify an ordinal spellout:
 ```ruby
 DateTime.now.localize(:es).to_full_s               # "viernes, 14 de febrero de 2014, 12:20:05 (tiempo universal coordinado)"
 DateTime.now.localize(:es).to_long_s               # "14 de febrero de 2014, 12:20:05 UTC"
-DateTime.now.localize(:es).to_medium_s             # "14 feb. 2014 12:20:05"
-DateTime.now.localize(:es).to_short_s              # "14/2/14 12:20"
+DateTime.now.localize(:es).to_medium_s             # "14 feb 2014, 12:20:05"
+DateTime.now.localize(:es).to_short_s              # "14/2/14, 12:20"
 
 Time.now.localize(:es).to_full_s                   # "12:20:05 (tiempo universal coordinado)"
 Time.now.localize(:es).to_long_s                   # "12:20:05 UTC"
@@ -187,7 +187,7 @@ Time.now.localize(:es).to_short_s                  # "12:20"
 
 DateTime.now.localize(:es).to_date.to_full_s       # "viernes, 14 de febrero de 2014"
 DateTime.now.localize(:es).to_date.to_long_s       # "14 de febrero de 2014"
-DateTime.now.localize(:es).to_date.to_medium_s     # "14 feb. 2014"
+DateTime.now.localize(:es).to_date.to_medium_s     # "14 feb 2014"
 DateTime.now.localize(:es).to_date.to_short_s      # "14/2/14"
 ```
 
@@ -239,6 +239,7 @@ It's important to know that, even though any given format may not be available a
 | GyMMM      | Feb 2014 CE            |
 | GyMMMEd    | Fri, Feb 14, 2014 CE   |
 | GyMMMd     | Feb 14, 2014 CE        |
+| GyMd       | 2/14/2014 Common Era   |
 | H          | 12                     |
 | Hm         | 12:20                  |
 | Hms        | 12:20:05               |
@@ -246,7 +247,7 @@ It's important to know that, even though any given format may not be available a
 | Hmv        | 12:20 GMT              |
 | M          | 2                      |
 | MEd        | Fri, 2/14              |
-| MMM        | Feb                    |
+| MMM        | M02                    |
 | MMMEd      | Fri, Feb 14            |
 | MMMMW      | week 3 of February     |
 | MMMMd      | February 14            |
@@ -366,6 +367,8 @@ tz.display_name_for(DateTime.new(2019, 11, 5), :generic_location)
 tz.display_name_for(DateTime.new(2019, 11, 5), :generic_long)
 ```
 
+`#display_name_for` also accepts arguments for resolving ambiguous times. See [TZInfo Documentation](https://www.rubydoc.info/gems/tzinfo/TZInfo/Timezone#period_for_local-instance_method) for more information.
+
 ### Calendar Data
 
 CLDR contains a trove of calendar data, much of which can be accessed. One example is names of months, days, years.
@@ -416,8 +419,8 @@ Behind the scenes, these convenience methods use the `TwitterCldr::Formatters::P
 TwitterCldr::Formatters::Plurals::Rules.all                # [:one, :other]
 
 # get all rules for a specific locale
-TwitterCldr::Formatters::Plurals::Rules.all_for(:es)       # [:one, :other]
-TwitterCldr::Formatters::Plurals::Rules.all_for(:ru)       # [:few, :many, :one, :other]
+TwitterCldr::Formatters::Plurals::Rules.all_for(:es)       # [:one, :many, :other]
+TwitterCldr::Formatters::Plurals::Rules.all_for(:ru)       # [:one, :few, :many, :other]
 
 # get the rule for a number in a specific locale
 TwitterCldr::Formatters::Plurals::Rules.rule_for(1, :ru)   # :one
@@ -498,21 +501,21 @@ In addition to translating language codes, TwitterCLDR provides access to the fu
 
 ```ruby
 # get all languages for the default locale
-TwitterCldr::Shared::Languages.all                                                  # { ... :vi => "Vietnamese", :"zh-Hant" => "Traditional Mandarin Chinese" ... }
+TwitterCldr::Shared::Languages.all                                                  # { ... :vi => "Vietnamese", :"zh-Hant" => "Traditional Chinese" ... }
 
 # get all languages for a specific locale
-TwitterCldr::Shared::Languages.all_for(:es)                                         # { ... :vi => "vietnamita", :"zh-Hant" => "chino mandarín tradicional" ... }
+TwitterCldr::Shared::Languages.all_for(:es)                                         # { ... :vi => "vietnamita", :"zh-Hant" => "chino tradicional" ... }
 
 # get a language by its code for the default locale
-TwitterCldr::Shared::Languages.from_code(:'zh-Hant')                                # "Traditional Mandarin Chinese"
+TwitterCldr::Shared::Languages.from_code(:'zh-Hant')                                # "Traditional Chinese"
 
 # get a language from its code for a specific locale
-TwitterCldr::Shared::Languages.from_code_for_locale(:'zh-Hant', :es)                # "chino mandarín tradicional"
+TwitterCldr::Shared::Languages.from_code_for_locale(:'zh-Hant', :es)                # "chino tradicional"
 
 # translate a language from one locale to another
 # signature: translate_language(lang, source_locale, destination_locale)
-TwitterCldr::Shared::Languages.translate_language("chino tradicional", :es, :en)    # "Traditional Mandarin Chinese"
-TwitterCldr::Shared::Languages.translate_language("Traditional Chinese", :en, :es)  # "chino mandarín tradicional"
+TwitterCldr::Shared::Languages.translate_language("chino tradicional", :es, :en)    # "Traditional Chinese"
+TwitterCldr::Shared::Languages.translate_language("Traditional Chinese", :en, :es)  # "chino tradicional"
 ```
 
 ### World Territories
@@ -558,20 +561,20 @@ The CLDR contains postal code validation regexes for a number of countries.
 
 ```ruby
 # United States
-postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:us)
+postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:us) 
 postal_code.valid?("94103")     # true
 postal_code.valid?("9410")      # false
 
 # England (Great Britain)
-postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:gb)
+postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:gb) 
 postal_code.valid?("BS98 1TL")  # true
 
 # Sweden
-postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:se)
+postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:se) 
 postal_code.valid?("280 12")    # true
 
 # Canada
-postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:ca)
+postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:ca) 
 postal_code.valid?("V3H 1Z7")   # true
 ```
 
@@ -579,7 +582,7 @@ Match all valid postal codes in a string with the `#find_all` method:
 
 ```ruby
 # United States
-postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:us)
+postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:us) 
 postal_code.find_all("12345 23456")    # ["12345", "23456"]
 ```
 
@@ -592,14 +595,14 @@ TwitterCldr::Shared::PostalCodes.territories  # [:ac, :ad, :af, :ai, :al, ... ]
 Just want the regex?  No problem:
 
 ```ruby
-postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:us)
+postal_code = TwitterCldr::Shared::PostalCodes.for_territory(:us) 
 postal_code.regexp  # /(\d{5})(?:[ \-](\d{4}))?/
 ```
 
 Get a sample of valid postal codes with the `#sample` method:
 
 ```ruby
-postal_code.sample(5)  # ["29294", "22486-2369", "76632", "40800-9860", "06727-6194"]
+postal_code.sample(5)  # ["60668-3382", "36022", "22364-5670", "32142-1738", "32633-0502"]
 ```
 
 ### Phone Codes
@@ -1014,17 +1017,17 @@ The Psych gem that is the default YAML engine in Ruby 1.9 doesn't handle Unicode
 You can make use of TwitterCLDR's YAML dumper by calling `localize` and then `to_yaml` on an `Array`, `Hash`, or `String`:
 
 ```ruby
-{ :hello => "world" }.localize.to_yaml
-["hello", "world"].localize.to_yaml
-"hello, world".localize.to_yaml
+{ :hello => "world" }.localize.to_yaml 
+["hello", "world"].localize.to_yaml 
+"hello, world".localize.to_yaml 
 ```
 
 Behind the scenes, these convenience methods are using the `TwitterCldr::Shared::YAML` class.  You can do the same thing if you're feeling adventurous:
 
 ```ruby
-TwitterCldr::Shared::YAML.dump({ :hello => "world" })
-TwitterCldr::Shared::YAML.dump(["hello", "world"])
-TwitterCldr::Shared::YAML.dump("hello, world")
+TwitterCldr::Shared::YAML.dump({ :hello => "world" }) 
+TwitterCldr::Shared::YAML.dump(["hello", "world"]) 
+TwitterCldr::Shared::YAML.dump("hello, world") 
 ```
 
 ## Adding New Locales
@@ -1070,7 +1073,7 @@ TwitterCldr.locale    # will return :ru
 
 ## Compatibility
 
-TwitterCLDR is fully compatible with Ruby 1.9.3, 2.0.0, 2.2.0.
+TwitterCLDR is fully compatible with Ruby 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0.
 
 ## Requirements
 
@@ -1103,6 +1106,6 @@ TwitterCLDR currently supports localization of certain textual objects in JavaSc
 
 ## License
 
-Copyright 2019 Twitter, Inc.
+Copyright 2021 Twitter, Inc.
 
 Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0

data/Rakefile

@@ -13,7 +13,7 @@ require 'rubygems/package_task'
 
 require './lib/twitter_cldr'
 
-require 'pry-byebug'
+require 'pry-byebug' unless RUBY_PLATFORM == 'java'
 
 Bundler::GemHelper.install_tasks
 
@@ -141,6 +141,16 @@ namespace :update do
     TwitterCldr::Resources::UnicodePropertyAliasesImporter.new.import
   end
 
+  desc 'Import unit data'
+  task :units do
+    TwitterCldr::Resources::UnitsImporter.new.import
+  end
+
+  desc 'Import calendar data'
+  task :calendars do
+    TwitterCldr::Resources::CalendarsImporter.new.import
+  end
+
   desc 'Generate the casefolder class. Depends on unicode data'
   task :casefolder do
     TwitterCldr::Resources::CasefolderClassGenerator.new.import

data/lib/twitter_cldr/formatters/formatter.rb

@@ -26,10 +26,6 @@ module TwitterCldr
         token.value.gsub(/'([^']+)'/, '\1') # remove single-quote escaping for "real" characters
       end
 
-      def format_composite(token, index, obj, options)
-        eval(format(token.tokens, obj)).to_s
-      end
-
     end
   end
 end

data/lib/twitter_cldr/resources/calendars_importer.rb

@@ -0,0 +1,222 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'nokogiri'
+require 'fileutils'
+require 'parallel'
+require 'etc'
+require 'set'
+
+module TwitterCldr
+  module Resources
+
+    class CalendarsImporter < Importer
+
+      requirement :cldr, Versions.cldr_version
+      output_path 'locales'
+      locales TwitterCldr.supported_locales
+      ruby_engine :mri
+
+      private
+
+      def execute
+        locales = Set.new
+
+        finish = -> (locale, *) do
+          locales.add(locale)
+          STDOUT.write "\rImported #{locale}, #{locales.size} of #{params[:locales].size} total"
+        end
+
+        Parallel.each(params[:locales], in_processes: Etc.nprocessors, finish: finish) do |locale|
+          import_locale(locale)
+          locales << locale
+        end
+      end
+
+      def import_locale(locale)
+        data = requirements[:cldr].build_data(locale) do |ancestor_locale|
+          GregorianCalendar.new(ancestor_locale, requirements[:cldr]).to_h
+        end
+
+        output_file = File.join(output_path, locale.to_s, 'calendars.yml')
+        FileUtils.mkdir_p(File.dirname(output_file))
+
+        File.open(output_file, 'w:utf-8') do |output|
+          output.write(
+            TwitterCldr::Utils::YAML.dump(
+              TwitterCldr::Utils.deep_symbolize_keys(locale => data),
+              use_natural_symbols: true
+            )
+          )
+        end
+      end
+
+      def output_path
+        params.fetch(:output_path)
+      end
+
+    end
+
+
+    class GregorianCalendar
+      ERA_TAGS = ['eraNames', 'eraAbbr', 'eraNarrow'].freeze
+
+      attr_reader :locale, :cldr_req
+
+      def initialize(locale, cldr_req)
+        @locale = locale
+        @cldr_req = cldr_req
+      end
+
+      def to_h
+        {
+          calendars: {
+            gregorian: {
+              days:     contexts('day'),
+              months:   contexts('month'),
+              eras:     eras,
+              quarters: contexts('quarter'),
+              periods:  contexts('dayPeriod', group: "alt"),
+              fields:   fields,
+              formats: {
+                date:     formats('date'),
+                time:     formats('time'),
+                datetime: formats('dateTime')
+              },
+              additional_formats: additional_formats
+            }
+          }
+        }
+      end
+
+      private
+
+      def calendar
+        @calendar ||= docset.xpath('//ldml/dates/calendars/calendar[@type="gregorian"]').first
+      end
+
+      def contexts(kind, options = {})
+        return {} unless calendar
+
+        dtd.find_attr("#{kind}Context", 'type').values.each_with_object({}) do |context, result|
+          node = calendar.xpath("#{kind}s/#{kind}Context[@type='#{context}']").first
+          next unless node
+
+          result[context] = widths(node, kind, context, options)
+        end
+      end
+
+      def widths(node, kind, context, options = {})
+        dtd.find_attr("#{kind}Width", 'type').values.each_with_object({}) do |width, result|
+          width_node = node.xpath("#{kind}Width[@type='#{width}']").first
+          next unless width_node
+
+          result[width] = elements(width_node, kind, context, width, options)
+        end
+      end
+
+      def elements(node, kind, context, width, options = {})
+        node.xpath(kind).each_with_object({}) do |node, result|
+          key = node.attribute('type').value
+          key = key =~ /^\d*$/ ? key.to_i : key.to_sym
+
+          if options[:group] && found_group = node.attribute(options[:group])
+            result[found_group.value] ||= {}
+            result[found_group.value][key] = node.content
+          else
+            result[key] = node.content
+          end
+        end
+      end
+
+      def periods
+        am = calendar.xpath("am").first
+        pm = calendar.xpath("pm").first
+
+        {}.tap do |result|
+          result[:am] = am.content if am
+          result[:pm] = pm.content if pm
+        end
+      end
+
+      def eras
+        return {} unless calendar
+
+        ERA_TAGS.each_with_object({}) do |era_tag, result|
+          key  = era_tag.gsub('era', '').gsub(/s$/, '').downcase.to_sym
+          path = "eras/#{era_tag}"
+
+          result[key] = dtd.find_attr('era', 'type').values.each_with_object({}) do |type, ret|
+            node = calendar.xpath("#{path}/era[@type='#{type}' and @alt='variant']").first ||
+              calendar.xpath("#{path}/era[@type='#{type}']").first
+            ret[type] = node.content if node
+            ret
+          end
+        end
+      end
+
+      def formats(type)
+        return {} unless calendar
+
+        formats = dtd.find_attr("#{type}FormatLength", 'type').values.each_with_object({}) do |format_length, result|
+          node = calendar.xpath("#{type}Formats/#{type}FormatLength[@type='#{format_length}']").first
+          result[format_length] = pattern(node, type) if node
+        end
+
+        if default = default_format(type)
+          formats = default.merge(formats)
+        end
+
+        formats
+      end
+
+      def additional_formats
+        return {} unless calendar
+
+        dtd.find_attr('dateFormatItem', 'id').values.each_with_object({}) do |id, result|
+          node = calendar.xpath("dateTimeFormats/availableFormats/dateFormatItem[@id='#{id}']").first
+          result[id] = node.content if node
+        end
+      end
+
+      def default_format(type)
+        if node = calendar.xpath("#{type}Formats/default").first
+          key = node.attribute('choice').value.to_sym
+          { :default => :"calendars.gregorian.formats.#{type.downcase}.#{key}" }
+        end
+      end
+
+      def pattern(node, type)
+        node.xpath("#{type}Format/pattern").each_with_object({}) do |node, result|
+          pattern = node.content
+          pattern = pattern.gsub('{0}', '{{time}}').gsub('{1}', '{{date}}') if type == 'dateTime'
+          result[:pattern] = pattern
+        end
+      end
+
+      def fields
+        dtd.find_attr('field', 'type').values.each_with_object({}) do |field, result|
+          node = docset.xpath("//ldml/dates/fields/field[@type='#{field}']").first
+          name = node.xpath('displayName').first
+          result[field] = name.content if name
+        end
+      end
+
+      def docset
+        @docset ||= cldr_req.docset(cldr_main_path, locale)
+      end
+
+      def cldr_main_path
+        @cldr_main_path ||= File.join(cldr_req.common_path, 'main')
+      end
+
+      def dtd
+        cldr_req.dtd
+      end
+
+    end
+
+  end
+end

data/lib/twitter_cldr/resources/cldr_data_builder.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'nokogiri'
+
+module TwitterCldr
+  module Resources
+
+    class CldrDataBuilder
+      DEEP_MERGER = proc do |key, v1, v2|
+        Hash === v1 && Hash === v2 ? v1.merge(v2, &DEEP_MERGER) : (v2 || v1)
+      end
+
+      attr_reader :cldr_locale
+
+      def initialize(cldr_locale)
+        @cldr_locale = cldr_locale
+      end
+
+      def merge_each_ancestor
+        cldr_locale.ancestors.inject({}) do |result, ancestor_locale|
+          deep_merge(yield(ancestor_locale), result)
+        end
+      end
+
+      private
+
+      def deep_merge(h1, h2)
+        h1.merge(h2, &DEEP_MERGER)
+      end
+    end
+
+  end
+end

data/lib/twitter_cldr/resources/cldr_document_set.rb

@@ -0,0 +1,149 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'forwardable'
+require 'nokogiri'
+
+module TwitterCldr
+  module Resources
+    class CldrDocumentSet
+
+      class Element
+        extend Forwardable
+
+        def_delegators :@element, :attribute, :content, :name, :path
+
+        attr_reader :docset, :element
+
+        def initialize(docset, element)
+          @docset = docset
+          @element = element
+        end
+
+        def xpath(path)
+          path = CldrDocumentSet.join_xpaths(docset.path_for(element), path)
+          docset.xpath(path)
+        end
+      end
+
+      class ElementList
+        include Enumerable
+        extend Forwardable
+
+        def_delegators :@elements, :size
+
+        attr_reader :docset, :elements
+
+        def initialize(docset, elements)
+          @docset = docset
+          @elements = elements
+        end
+
+        def [](idx)
+          return unless elements[idx]
+
+          Element.new(docset, elements[idx])
+        end
+
+        def first
+          self[0]
+        end
+
+        def each
+          return to_enum(__method__) unless block_given?
+
+          elements.size.times do |idx|
+            yield self[idx]
+          end
+        end
+      end
+
+
+      def self.join_xpaths(*paths)
+        paths.map { |a| a.chomp('/') }.join('/')
+      end
+
+      attr_reader :path, :cldr_locale, :cldr_requirement
+
+      def initialize(path, cldr_locale, cldr_requirement)
+        @path = path
+        @cldr_locale = cldr_locale
+        @cldr_requirement = cldr_requirement
+      end
+
+
+      def xpath(path)
+        cldr_locale.ancestors.each do |ancestor_locale|
+          data = doc_for(ancestor_locale).xpath(path)
+
+          unless data.empty?
+            return ElementList.new(self, resolve_aliases_in(data))
+          end
+        end
+
+        ElementList.new(self, [])
+      end
+
+      def path_for(node)
+        orig_node = node
+        path = []
+
+        while node
+          path << selector_for(node)
+          node = node.parent
+          break if node.name == 'document'
+        end
+
+        "//#{path.reverse.join('/')}"
+      end
+
+      private
+
+      def resolve_aliases_in(data)
+        alias_nodes = data.xpath('.//alias')
+        alias_nodes.each do |alias_node|
+          alias_path = alias_node.attribute('path').value
+          full_path = join_xpaths(path_for(alias_node.parent), alias_path)
+
+          cldr_locale.ancestors.find do |ancestor_locale|
+            resolved_node = doc_for(ancestor_locale).xpath(full_path).first.dup
+
+            if resolved_node
+              resolved_copy = Nokogiri::XML(resolved_node.to_xml).children.first
+              parent = alias_node.parent
+              alias_node.replace(resolved_copy.children)
+              resolve_aliases_in(parent)
+              break
+            end
+          end
+        end
+
+        data
+      end
+
+      def join_xpaths(*paths)
+        self.class.join_xpaths(*paths)
+      end
+
+      def selector_for(node)
+        node.name.dup.tap do |selector|
+          if type = node.attribute('type')
+            selector << "[@type='#{type.value}']"
+          end
+        end
+      end
+
+      def doc_for(locale)
+        locale_fs = locale.to_s.gsub('-', '_')
+        docs[locale_fs] ||= Nokogiri.XML(File.read(File.join(path, "#{locale_fs}.xml")))
+      end
+
+      def docs
+        @docs ||= {}
+      end
+    end
+
+  end
+end