icu4x 0.5.2 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3566fdace3fcdd76408d7320b01e555fbce71a928ec83d43a6b7c1503008a32b
-  data.tar.gz: e278d1a619e2d930e186a93f7ae8a40ce63d9e818f12297884ee5e0512709027
+  metadata.gz: 28ab1937c0157603296c359e3ee392c9daf61ab75b88814bd59c0e448558d288
+  data.tar.gz: 6f867d51c15a78a9f8d52a1cc41fe6a85fe5195a78dc31f3d08168db77858e1b
 SHA512:
-  metadata.gz: a299b04d9a3e3577d0a70484b3d0e9f73780087ccd9a26acf6cc28d3c7dc6b6bca9f80d81a5cc9eeafe7fed4670b67f9c7fd07930fb4881bb55be51e68cc1d27
-  data.tar.gz: 9b0d36fc12bc252dc295ffd4507d4e524d5c87b70581ade2e712169bb0bdc5ccdd50a40a53ba8ed5fbe7479ec0cd90fbd2775904d04cbb730736d8e643f770c1
+  metadata.gz: 4ab2852087c12adad3275197b50915e1d0c1b29111e3428c35c43d04864734e4d081b22700a6cf25408bfb74326964a6de38318f6bebddd2635b7978d516c449
+  data.tar.gz: 4293277c12231a11a52e6686874238d994b5cb438e2e780a66c26f8cdc906ec54bf6af1f4982c24ac1eb27474e980e7420bf84676096a16e8497f3ff4b396216

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [0.6.1] - 2026-01-02
+
+### Changed
+
+- Re-release to publish companion data gems with Trusted Publisher configuration
+
+## [0.6.0] - 2026-01-02
+
+### Added
+
+- **Companion data gems**: `icu4x-data-full`, `icu4x-data-recommended`, `icu4x-data-modern` for bundled locale data
+  - Auto-configures default provider on require (e.g., `require "icu4x/data/recommended"`)
+- **RakeTask**: `ICU4X::RakeTask` for integrating data generation into build workflows
+- **Symbolic locale specifiers**: `DataGenerator.export` accepts `:full`, `:recommended`, `:modern`, `:moderate`, `:basic` symbols
+- **Automatic 'und' locale**: `DataGenerator.export` automatically includes the `und` (undetermined) locale for fallback
+
 ## [0.5.2] - 2026-01-01
 
 ### Fixed

data/README.md

@@ -35,7 +35,28 @@ Add to your Gemfile:
 gem "icu4x"
 ```
 
-Then generate locale data for your application:
+### Option 1: Use Pre-built Data Gem (Quick Start)
+
+Add a companion data gem for instant setup:
+
+```ruby
+gem "icu4x"
+gem "icu4x-data-recommended"  # 164 locales, ~24MB
+```
+
+```ruby
+require "icu4x"
+require "icu4x/data/recommended"  # Auto-configures default provider
+```
+
+Available data gems:
+- `icu4x-data-full` - All CLDR locales (700+)
+- `icu4x-data-recommended` - Recommended locales (164)
+- `icu4x-data-modern` - Modern coverage locales (103)
+
+### Option 2: Generate Custom Data
+
+For fine-grained control, generate only the locales you need:
 
 ```ruby
 require "icu4x"

data/ext/icu4x/src/data_generator.rs

@@ -2,7 +2,7 @@ use crate::helpers;
 use icu_provider::DataMarkerInfo;
 use icu_provider_blob::export::BlobExporter;
 use icu_provider_export::prelude::*;
-use icu_provider_source::SourceDataProvider;
+use icu_provider_source::{CoverageLevel, SourceDataProvider};
 use magnus::{
     Error, RArray, RClass, RHash, RModule, Ruby, Symbol, Value, function, prelude::*,
     value::ReprValue,
@@ -44,14 +44,17 @@ impl DataGenerator {
     /// Export ICU4X data to a blob file
     ///
     /// # Arguments
-    /// * `locales` - Array of locale strings (e.g., ["ja", "en"])
+    /// * `locales` - Symbol (:full, :recommended, :modern, :moderate, :basic) or Array of locale strings
     /// * `markers` - :all or Array of marker symbols (e.g., [:datetime, :number, :plurals])
     /// * `format` - :blob (only blob format is supported)
     /// * `output` - Pathname for the output file
     fn export(ruby: &Ruby, kwargs: RHash) -> Result<(), Error> {
-        // Extract locales
-        let locales_value: RArray = kwargs
-            .fetch::<_, RArray>(ruby.to_symbol("locales"))
+        // Create the source data provider early (needed for coverage level locales)
+        let source_provider = SourceDataProvider::new();
+
+        // Extract locales - can be a Symbol or Array<String>
+        let locales_value: Value = kwargs
+            .fetch::<_, Value>(ruby.to_symbol("locales"))
             .map_err(|_| {
                 Error::new(
                     ruby.exception_arg_error(),
@@ -59,30 +62,7 @@ impl DataGenerator {
                 )
             })?;
 
-        let mut locale_families: Vec<DataLocaleFamily> = Vec::new();
-        let mut has_und = false;
-        for i in 0..locales_value.len() {
-            let locale_str: String = locales_value.entry(i as isize)?;
-            if locale_str == "und" {
-                has_und = true;
-            }
-            let family = DataLocaleFamily::with_descendants(locale_str.parse().map_err(|e| {
-                Error::new(
-                    ruby.exception_arg_error(),
-                    format!("Invalid locale '{}': {}", locale_str, e),
-                )
-            })?);
-            locale_families.push(family);
-        }
-
-        // Warn if 'und' locale is not included
-        if !has_und {
-            let kernel: Value = ruby.eval("Kernel")?;
-            let _: Value = kernel.funcall(
-                "warn",
-                ("ICU4X::DataGenerator.export: 'und' locale not included. Fallback may fail for unlisted locales.",),
-            )?;
-        }
+        let locale_families = Self::parse_locales(ruby, locales_value, &source_provider)?;
 
         // Extract markers
         let markers_value: Value = kwargs
@@ -180,9 +160,6 @@ impl DataGenerator {
             })?;
         }
 
-        // Create the source data provider (downloads CLDR data)
-        let source_provider = SourceDataProvider::new();
-
         // Create the blob exporter
         let file = File::create(&output_path).map_err(|e| {
             Error::new(
@@ -231,6 +208,83 @@ impl DataGenerator {
         }
         Ok(array)
     }
+
+    /// Parse locales from Ruby value (Symbol or Array)
+    fn parse_locales(
+        ruby: &Ruby,
+        locales_value: Value,
+        source_provider: &SourceDataProvider,
+    ) -> Result<Vec<DataLocaleFamily>, Error> {
+        // Check if it's a symbol
+        if let Ok(symbol) = Symbol::try_convert(locales_value) {
+            let symbol_name = symbol.name()?;
+            match symbol_name.as_ref() {
+                "full" => Ok(vec![DataLocaleFamily::FULL]),
+                "modern" => Self::locales_from_coverage(ruby, source_provider, &[CoverageLevel::Modern]),
+                "moderate" => {
+                    Self::locales_from_coverage(ruby, source_provider, &[CoverageLevel::Moderate])
+                }
+                "basic" => Self::locales_from_coverage(ruby, source_provider, &[CoverageLevel::Basic]),
+                "recommended" => Self::locales_from_coverage(
+                    ruby,
+                    source_provider,
+                    &[
+                        CoverageLevel::Modern,
+                        CoverageLevel::Moderate,
+                        CoverageLevel::Basic,
+                    ],
+                ),
+                name => Err(Error::new(
+                    ruby.exception_arg_error(),
+                    format!(
+                        "unknown locale specifier: :{}. Valid options are :full, :recommended, :modern, :moderate, :basic",
+                        name
+                    ),
+                )),
+            }
+        } else if let Ok(array) = RArray::try_convert(locales_value) {
+            // Array of locale strings
+            let mut families = Vec::new();
+            for i in 0..array.len() {
+                let locale_str: String = array.entry(i as isize)?;
+                let family = DataLocaleFamily::with_descendants(locale_str.parse().map_err(|e| {
+                    Error::new(
+                        ruby.exception_arg_error(),
+                        format!("Invalid locale '{}': {}", locale_str, e),
+                    )
+                })?);
+                families.push(family);
+            }
+            Ok(families)
+        } else {
+            Err(Error::new(
+                ruby.exception_arg_error(),
+                "locales must be a Symbol (:full, :recommended, :modern, :moderate, :basic) or an Array of locale strings",
+            ))
+        }
+    }
+
+    /// Get locales from CLDR coverage levels
+    fn locales_from_coverage(
+        ruby: &Ruby,
+        source_provider: &SourceDataProvider,
+        levels: &[CoverageLevel],
+    ) -> Result<Vec<DataLocaleFamily>, Error> {
+        let locales = source_provider
+            .locales_for_coverage_levels(levels.iter().copied())
+            .map_err(|e| {
+                let error_class = helpers::get_exception_class(ruby, "ICU4X::DataGeneratorError");
+                Error::new(
+                    error_class,
+                    format!("Failed to get locales for coverage levels: {}", e),
+                )
+            })?;
+
+        Ok(locales
+            .into_iter()
+            .map(DataLocaleFamily::with_descendants)
+            .collect())
+    }
 }
 
 pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {

data/lib/icu4x/data_gem_task.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "erb"
+require "fileutils"
+require "pathname"
+require "rake"
+require "rake/tasklib"
+require "rubygems"
+require "rubygems/package"
+
+module ICU4X
+  # Rake task for generating ICU4X data companion gems.
+  #
+  # @example Basic usage
+  #   require "icu4x/data_gem_task"
+  #
+  #   ICU4X::DataGemTask.new
+  #
+  # This creates the following tasks:
+  # - +icu4x:data_gems:build+ - Build all data gems
+  # - +icu4x:data_gems:build:full+ - Build icu4x-data-full gem
+  # - +icu4x:data_gems:build:recommended+ - Build icu4x-data-recommended gem
+  # - +icu4x:data_gems:build:modern+ - Build icu4x-data-modern gem
+  # - +icu4x:data_gems:clean+ - Clean data gem build artifacts
+  class DataGemTask < ::Rake::TaskLib
+    VARIANTS = {
+      full: {locales: :full, description: "All CLDR locales (700+)"},
+      recommended: {locales: :recommended, description: "Recommended locales (164)"},
+      modern: {locales: :modern, description: "Modern coverage locales (103)"}
+    }.freeze
+    public_constant :VARIANTS
+
+    TEMPLATE_DIR = Pathname(__dir__).join("../../templates/data_gem")
+    public_constant :TEMPLATE_DIR
+
+    def initialize
+      super
+      define_tasks
+    end
+
+    private def define_tasks
+      namespace "icu4x:data_gems" do
+        desc "Build all data gems"
+        task build: VARIANTS.keys.map {|v| "build:#{v}" }
+
+        VARIANTS.each do |variant, config|
+          desc "Build icu4x-data-#{variant} gem"
+          task "build:#{variant}" => :compile do
+            build_gem(variant, config)
+          end
+        end
+
+        desc "Clean data gem build artifacts"
+        task :clean do
+          VARIANTS.each_key {|v| FileUtils.rm_rf(tmp_dir(v)) }
+        end
+      end
+    end
+
+    private def build_gem(variant, config)
+      gem_dir = prepare_gem_structure(variant, config)
+      generate_data_blob(gem_dir, variant, config[:locales])
+      package_gem(gem_dir, variant)
+    end
+
+    private def prepare_gem_structure(variant, config)
+      gem_dir = tmp_dir(variant)
+      FileUtils.rm_rf(gem_dir)
+      gem_dir.mkpath
+
+      # Render templates
+      require "icu4x/version"
+      render_template(
+        "gemspec.erb",
+        gem_dir / "icu4x-data-#{variant}.gemspec",
+        variant:,
+        config:,
+        version: ICU4X::VERSION
+      )
+      render_template(
+        "README.md.erb",
+        gem_dir / "README.md",
+        variant:,
+        config:
+      )
+
+      lib_data_dir = gem_dir / "lib" / "icu4x" / "data"
+      lib_data_dir.mkpath
+      render_template(
+        "lib/icu4x/data/variant.rb.erb",
+        lib_data_dir / "#{variant}.rb",
+        variant:
+      )
+
+      # Copy LICENSE
+      FileUtils.cp("LICENSE.txt", gem_dir / "LICENSE.txt")
+
+      gem_dir
+    end
+
+    private def generate_data_blob(gem_dir, variant, locales)
+      data_dir = gem_dir / "data"
+      data_dir.mkpath
+
+      require "icu4x"
+      ICU4X::DataGenerator.export(
+        locales:,
+        markers: :all,
+        format: :blob,
+        output: data_dir / "#{variant}.postcard"
+      )
+    end
+
+    private def package_gem(gem_dir, variant)
+      Dir.chdir(gem_dir) do
+        spec = Gem::Specification.load("icu4x-data-#{variant}.gemspec")
+        gem_file = Gem::Package.build(spec)
+        pkg_dir = Pathname("../../pkg")
+        pkg_dir.mkpath
+        FileUtils.mv(gem_file, pkg_dir / gem_file)
+      end
+    end
+
+    private def render_template(template_name, output_path, **locals)
+      template = ERB.new(TEMPLATE_DIR.join(template_name).read, trim_mode: "-")
+      binding_with_locals = binding
+      locals.each {|k, v| binding_with_locals.local_variable_set(k, v) }
+      output_path.write(template.result(binding_with_locals))
+    end
+
+    private def tmp_dir(variant) = Pathname("tmp/icu4x-data-#{variant}")
+  end
+end

data/lib/icu4x/rake_task.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "rake"
+require "rake/clean"
+require "rake/tasklib"
+
+module ICU4X
+  # Rake task for generating ICU4X data blobs.
+  #
+  # @example Basic usage
+  #   require "icu4x/rake_task"
+  #
+  #   ICU4X::RakeTask.new do |t|
+  #     t.output = "data/icu4x.postcard"
+  #   end
+  #
+  # @example Custom task name and locales
+  #   ICU4X::RakeTask.new("myapp:generate_data") do |t|
+  #     t.locales = %w[en ja de]
+  #     t.output = "data/icu4x.postcard"
+  #   end
+  class RakeTask < ::Rake::TaskLib
+    # @return [String] The name of the task
+    attr_reader :name
+
+    # @return [Symbol, Array<String>] Locale specifier or array of locale strings
+    #   Defaults to +:recommended+
+    attr_accessor :locales
+
+    # @return [Symbol, Array<String>] Data markers to include
+    #   Defaults to +:all+
+    attr_accessor :markers
+
+    # @return [Pathname, String] Output path relative to Rakefile
+    attr_accessor :output
+
+    # Creates a new RakeTask.
+    #
+    # @param name [String] Task name (default: "icu4x:data:generate")
+    # @yield [self] Configuration block
+    # @yieldparam task [RakeTask] The task instance for configuration
+    def initialize(name="icu4x:data:generate")
+      super()
+      @name = name
+      @locales = :recommended
+      @markers = :all
+      @output = nil
+
+      yield self if block_given?
+
+      raise ArgumentError, "output is required" if @output.nil?
+
+      define_tasks
+    end
+
+    private def define_tasks
+      output_path = Pathname(@output)
+
+      desc "Generate ICU4X data blob"
+      file output_path.to_s do
+        require "icu4x"
+        output_path.dirname.mkpath
+        ICU4X::DataGenerator.export(
+          locales: @locales,
+          markers: @markers,
+          format: :blob,
+          output: output_path
+        )
+      end
+
+      desc "Generate ICU4X data blob"
+      task @name => output_path.to_s
+
+      CLOBBER.include(output_path.to_s)
+    end
+  end
+end

data/lib/icu4x/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module ICU4X
-  VERSION = "0.5.2"
+  VERSION = "0.6.1"
   public_constant :VERSION
 end

data/lib/icu4x/yard_docs.rb

@@ -112,7 +112,18 @@
 #     class DataGenerator
 #       # Exports locale data to a file.
 #       #
-#       # @param locales [Array<String>] list of locale identifiers to include
+#       # The +locales+ parameter accepts either a Symbol for predefined locale sets
+#       # based on CLDR coverage levels, or an Array of locale identifier strings.
+#       # When using +with_descendants+, ancestor locales (including +und+) are
+#       # automatically included for fallback support.
+#       #
+#       # @param locales [Symbol, Array<String>] locale specification:
+#       #   - +:full+ - all CLDR locales (700+)
+#       #   - +:recommended+ - locales with basic, moderate, or modern coverage (164)
+#       #   - +:modern+ - locales with modern coverage only (103)
+#       #   - +:moderate+ - locales with moderate coverage only
+#       #   - +:basic+ - locales with basic coverage only
+#       #   - +Array<String>+ - explicit list of locale identifiers
 #       # @param markers [Symbol, Array<String>] data markers to include;
 #       #   use +:all+ for all markers, or specify individual marker names
 #       # @param format [Symbol] output format, currently only +:blob+ is supported
@@ -128,7 +139,16 @@
 #       #     output: Pathname.new("i18n_data.postcard")
 #       #   )
 #       #
+#       # @example Export data for all modern coverage locales
+#       #   ICU4X::DataGenerator.export(
+#       #     locales: :modern,
+#       #     markers: :all,
+#       #     format: :blob,
+#       #     output: Pathname.new("modern_data.postcard")
+#       #   )
+#       #
 #       # @see .available_markers
+#       # @see https://cldr.unicode.org/index/cldr-spec/coverage-levels CLDR Coverage Levels
 #       #
 #       def self.export(locales:, markers:, format:, output:); end
 #
@@ -138,7 +158,7 @@
 #       #
 #       # @example
 #       #   markers = ICU4X::DataGenerator.available_markers
-#       #   #=> ["datetime/gregory/datelengths@1", "decimal/symbols@1", ...]
+#       #   #=> ["CalendarJapaneseExtendedV1", "CalendarJapaneseModernV1", ...]
 #       #
 #       def self.available_markers; end
 #     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: icu4x
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.1
 platform: ruby
 authors:
 - OZAWA Sakuro
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-01 00:00:00.000000000 Z
+date: 2026-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -69,6 +69,8 @@ files:
 - ext/icu4x_macros/Cargo.toml
 - ext/icu4x_macros/src/lib.rs
 - lib/icu4x.rb
+- lib/icu4x/data_gem_task.rb
+- lib/icu4x/rake_task.rb
 - lib/icu4x/version.rb
 - lib/icu4x/yard_docs.rb
 - sig/icu4x.rbs