### Command Line Usage

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This section provides examples for using the Ruby CLDR library via the command line using Thor commands for downloading and exporting CLDR data.

```APIDOC
## Command Line Usage

### Description
Utilize the `thor` commands provided by the Ruby CLDR gem to download and export CLDR data from the command line.

### Method
Command Line Interface (CLI)

### Endpoint
N/A (CLI Commands)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```bash
# Download CLDR data using Thor command
bundle install
thor cldr:download

# Download specific version
thor cldr:download --version=45

# Download to custom directory
thor cldr:download --target=./vendor/my_cldr --version=44

# Download from custom URL
thor cldr:download --source=https://example.com/cldr.zip

# Export all locales and components to default directory
thor cldr:export

# Export specific locales and components
thor cldr:export \
  --locales de fr-FR en-ZA \
  --components Numbers Plurals Calendars \
  --target=./output
```

### Response
#### Success Response (200)

- **Output**: Console output indicating download progress, extraction, or export status.

#### Response Example
```
Downloaded core.zip to ./vendor/cldr
Extracted: ./vendor/cldr/common/main/en.xml
Exported Numbers for de to ./data/locales/de/numbers.yml
```
```

--------------------------------

### Export Calendar Data (Ruby)

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

Illustrates exporting calendar data, including month and day names, and date/time formats for a specified locale using `Cldr::Export::Data::Calendars`. Examples show accessing wide format month names and day abbreviations.

```ruby
require 'cldr/export/data/calendars'

# Get Gregorian calendar data for a locale
calendars = Cldr::Export::Data::Calendars.new(:de)
gregorian = calendars[:calendars][:gregorian]

# Access month names
months = gregorian[:months][:format][:wide]
puts months[1]  # "Januar"
puts months[12] # "Dezember"

# Access day names
days = gregorian[:days][:format][:wide]
puts days[:mon]  # "Montag"
puts days[7]  # "Sonntag"

# Date and time formats
formats = gregorian[:formats]
puts formats[:date][:full]
# "EEEE, d. MMMM y"
```

--------------------------------

### Access Locale Fallbacks (Ruby)

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

Explains how to access locale fallback chains using the `Cldr.fallbacks` method in Ruby. It provides examples for different locale formats, showing their respective fallback sequences up to the root locale.

```ruby
require 'cldr'

# Get fallback chain for a locale
fallbacks = Cldr.fallbacks
chain = fallbacks[:'pt-BR']
puts chain.inspect
# [:pt-BR, :pt, :root]

# British English fallback
uk_chain = fallbacks[:'en-GB']
puts uk_chain.inspect
# [:en-GB, :"en-001", :en, :root]

# Fallbacks respect parent locale relationships defined in CLDR
```

--------------------------------

### Download CLDR Data using Thor CLI

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This shows how to download CLDR data using the Thor command-line interface. It includes options for downloading the default version, a specific version, to a custom directory, or from a custom URL.

```bash
# Download CLDR data using Thor command
bundle install
thor cldr:download

# Download specific version
thor cldr:download --version=45

# Download to custom directory
thor cldr:download --target=./vendor/my_cldr --version=44

# Download from custom URL
thor cldr:download --source=https://example.com/cldr.zip
```

--------------------------------

### Export Currency Data (Ruby)

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

Shows how to export currency data for a given locale using `Cldr::Export::Data::Currencies`. It demonstrates accessing currency symbols, names, narrow symbols, and plural forms for currency names.

```ruby
require 'cldr/export/data/currencies'

# Create currency exporter for a locale
currencies = Cldr::Export::Data::Currencies.new(:en)

# Access currency information
usd = currencies[:currencies][:USD]
puts "Symbol: #{usd[:symbol]}"           # "$"
puts "Name: #{usd[:name]}"               # "US Dollar"
puts "Narrow: #{usd[:narrow_symbol]}"    # "$"

# Plural forms for currency names
eur = currencies[:currencies][:EUR]
puts eur[:one]    # "euro" (singular)
puts eur[:other]  # "euros" (plural)
```

--------------------------------

### Export Number Formatting Patterns (Ruby)

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

Demonstrates how to export number formatting patterns, including symbols and standard patterns for decimal and currency formats, for a given locale using `Cldr::Export::Data::Numbers`.

```ruby
require 'cldr/export/data/numbers'

# Get number formatting data
numbers = Cldr::Export::Data::Numbers.new(:de)
latn = numbers[:numbers][:latn]

# Number symbols
symbols = latn[:symbols]
puts "Decimal: #{symbols[:decimal]}"      # ","
puts "Group: #{symbols[:group]}"          # "."
puts "Percent: #{symbols[:percent_sign]}" # "%"

# Formatting patterns
decimal_pattern = latn[:formats][:decimal][:patterns][:default][:standard]
puts decimal_pattern
# "#,##0.###"

currency_pattern = latn[:formats][:currency][:patterns][:default][:standard]
puts currency_pattern
# "#,##0.00 ¤"
```

--------------------------------

### Export All Locales and Components with Ruby

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This Ruby snippet demonstrates exporting all available CLDR locales and components to the default directory './data'. It utilizes the Cldr::Export module and provides a callback to track the export process.

```ruby
require 'cldr/export'

# Export all locales and all components to default directory (./data)
Cldr::Export.export do |component, locale, output_path|
  puts "Exported #{component} for #{locale} to #{output_path}"
end

# Example output paths:
# ./data/locales/de/calendars.yml
# ./data/locales/en/numbers.yml
# ./data/plurals.rb
```

--------------------------------

### Download CLDR Data with Ruby

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This snippet shows how to download CLDR data using the Cldr::Download module. It supports downloading the default version to a default directory or specific versions to custom locations, with optional callbacks for extracted files.

```ruby
require 'cldr/download'

# Download the default CLDR version (41) to default directory
Cldr::Download.download

# Download specific version to custom directory
Cldr::Download.download(
  "http://unicode.org/Public/cldr/%{version}/core.zip",
  "./my_cldr_data",
  45
) do |file_path|
  puts "Extracted: #{file_path}"
end

# The method returns after extracting all files
# Default source: http://unicode.org/Public/cldr/41/core.zip
# Default target: ./vendor/cldr
```

--------------------------------

### Export CLDR Data with Draft Status and Locale Fallback

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

Demonstrates exporting CLDR data with specific draft statuses and locale fallback merging using the `thor` command-line tool. Supports specifying multiple locales and merging fallback data.

```bash
thor cldr:export \
  --locales ja ko zh \
  --draft-status=provisional

# Available draft statuses:
# unconfirmed, provisional, contributed (default), approved

thor cldr:export --locales de-AT en-GB --merge
```

--------------------------------

### Download CLDR Data

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This section details how to download CLDR data using the Ruby CLDR library. You can download the default version to the default directory, a specific version to a custom directory, or from a custom URL.

```APIDOC
## Download CLDR Data

### Description
Download CLDR data using the `Cldr::Download` module. Supports default, specific versions, and custom download locations.

### Method
Ruby Method Call

### Endpoint
N/A (Library Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```ruby
require 'cldr/download'

# Download the default CLDR version (41) to default directory
Cldr::Download.download

# Download specific version to custom directory
Cldr::Download.download(
  "http://unicode.org/Public/cldr/%{version}/core.zip",
  "./my_cldr_data",
  45
) do |file_path|
  puts "Extracted: #{file_path}"
end
```

### Response
#### Success Response (200)

- **file_path** (string) - Path to the extracted file.

#### Response Example
```
Extracted: ./my_cldr_data/common/main/en.xml
```
```

--------------------------------

### Validate Exported CLDR Data

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

Shows commands for validating exported CLDR data using the `thor` command-line tool. Includes validation of YAML files for consistency and upstream CLDR assumptions.

```bash
# Validate exported YAML files for consistency
thor cldr:validate --target=./data

# Validate upstream CLDR assumptions
thor cldr:validate_upstream
```

--------------------------------

### Extract Data Programmatically

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This section explains how to extract CLDR data programmatically using the `Cldr::Export.data` method. You can retrieve data for specific components and locales, with or without locale fallback.

```APIDOC
## Extract CLDR Data Programmatically

### Description
Retrieve CLDR data programmatically for specific components and locales. Supports merging data with locale fallbacks.

### Method
Ruby Method Call

### Endpoint
N/A (Library Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```ruby
require 'cldr/export'

# Get number formatting data for a specific locale
numbers_data = Cldr::Export.data(:Numbers, :de)
puts numbers_data[:numbers][:latn][:symbols][:decimal]

# Get currency data
currencies_data = Cldr::Export.data(:Currencies, :'en-US')
euro = currencies_data[:currencies][:EUR]
puts "#{euro[:symbol]} - #{euro[:name]}"

# Get data with fallback chain (de-AT -> de -> root)
merged_data = Cldr::Export.data(:Numbers, :'de-AT', merge: true)
puts merged_data[:numbers][:latn][:symbols][:nan]
```

### Response
#### Success Response (200)

- **data** (hash) - A nested hash containing the requested CLDR data.

#### Response Example
```
,
€ - Euro
NaN
```
```

--------------------------------

### Set Minimum Draft Status for Exports with Ruby

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This Ruby snippet demonstrates how to filter CLDR data exports based on a minimum draft status using Cldr::Export and Cldr::DraftStatus. It allows specifying statuses like 'approved' or 'provisional' to control data quality.

```ruby
require 'cldr/export'
require 'cldr/draft_status'

# Only export data with 'approved' status
Cldr::Export.export(
  locales: [:de, :en],
  components: [:Calendars],
  minimum_draft_status: Cldr::DraftStatus::APPROVED
)

# Export data with 'provisional' or better status
Cldr::Export.export(
  locales: [:ja],
  components: [:Numbers],
  minimum_draft_status: Cldr::DraftStatus::PROVISIONAL
)

# Draft status hierarchy (lowest to highest):
# UNCONFIRMED < PROVISIONAL < CONTRIBUTED < APPROVED
# Default: CONTRIBUTED
```

--------------------------------

### Export CLDR Data using Thor CLI

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This demonstrates exporting CLDR data via the Thor command-line interface. It supports exporting all locales and components or specifying particular locales and components along with a target directory.

```bash
# Export all locales and components to default directory
thor cldr:export

# Export specific locales and components
thor cldr:export \
  --locales de fr-FR en-ZA \
  --components Numbers Plurals Calendars \
  --target=./output
```

--------------------------------

### Access Plural Rules (Ruby)

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

Provides Ruby code to access pluralization rules for different locales using the `Cldr::Export::Data::Plurals` class. It shows how to retrieve all rules or rules for a specific locale, returning a hash of plural forms.

```ruby
require 'cldr/export/data/plurals'

# Get plural rules for all locales
all_rules = Cldr::Export::Data::Plurals.rules

# Get rules for specific locale
polish_rules = all_rules[:pl]
# Returns hash with plural forms: :one, :few, :many, :other

# Example structure:
# {
#   pl: {
#     i18n: {
#       plural: {
#         keys: [:one, :few, :many, :other],
#         rule: <compiled rule object>
#       }
#     }
#   }
# }
```

--------------------------------

### Custom CLDR Data Export Format

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

Demonstrates custom export formats for CLDR data using `Cldr::Export`. It shows how to export specific components (e.g., Plurals, Numbers, Currencies) in Ruby format instead of the default YAML.

```ruby
require 'cldr/export'

# Export as Ruby instead of YAML (for Plurals)
Cldr::Export.export(
  locales: [:en, :de],
  components: [:Plurals],
  format: :ruby
)
# Creates .rb files with executable Ruby code

# Export other components as YAML (default)
Cldr::Export.export(
  locales: [:en],
  components: [:Numbers, :Currencies],
  format: :yaml
)
# Creates .yml files
```

--------------------------------

### Extract CLDR Data Programmatically with Ruby

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This Ruby code shows how to programmatically extract specific CLDR data components like numbers or currencies for a given locale using Cldr::Export.data. It provides direct access to formatted data structures.

```ruby
require 'cldr/export'

# Get number formatting data for a specific locale
numbers_data = Cldr::Export.data(:Numbers, :de)
puts numbers_data[:numbers][:latn][:symbols][:decimal]
# Output: ","

# Get currency data
currencies_data = Cldr::Export.data(:Currencies, :'en-US')
euro = currencies_data[:currencies][:EUR]
puts "#{euro[:symbol]} - #{euro[:name]}"
# Output: "€ - Euro"

# Available components:
# :Calendars, :Numbers, :Currencies, :Plurals, :Territories,
# :Languages, :Timezones, :Units, :Fields, and more
```

--------------------------------

### Export Specific Locales and Components with Ruby

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This Ruby code exports specific CLDR components (e.g., Numbers, Plurals) for designated locales (e.g., German, French, English) to a custom target directory. It allows fine-grained control over the data exported.

```ruby
require 'cldr/export'

# Export only Numbers and Plurals for German, French, and English locales
Cldr::Export.export(
  locales: [:de, :'fr-FR', :'en-ZA'],
  components: [:Numbers, :Plurals],
  target: './my_locale_data'
) do |component, locale, path|
  puts "Created: #{path}"
end

# Resulting structure:
# ./my_locale_data/locales/de/numbers.yml
# ./my_locale_data/locales/fr-FR/numbers.yml
# ./my_locale_data/locales/en-ZA/numbers.yml
# ./my_locale_data/locales/de/plurals.rb
# ./my_locale_data/locales/fr-FR/plurals.rb
# ./my_locale_data/locales/en-ZA/plurals.rb
```

--------------------------------

### Merge CLDR Data with Locale Fallbacks in Ruby

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This Ruby snippet demonstrates how to retrieve CLDR data with locale fallback mechanisms enabled using Cldr::Export.data(..., merge: true). It allows accessing data from parent locales when specific data is not found in the requested locale.

```ruby
require 'cldr/export'

# Get data for Austrian German without fallback
data = Cldr::Export.data(:Numbers, :'de-AT')
# Returns only de-AT specific data

# Get data with fallback chain (de-AT -> de -> root)
merged_data = Cldr::Export.data(:Numbers, :'de-AT', merge: true)
puts merged_data[:numbers][:latn][:symbols][:nan]
# Output: "NaN" (inherited from parent locale)

# Fallback respects parent locale relationships
uk_data = Cldr::Export.data(:Calendars, :'en-GB', merge: true)
puts uk_data[:calendars][:gregorian][:additional_formats]["yMd"]
# Output: "dd/MM/y" (UK format, not US)
```

--------------------------------

### Export CLDR Data

Source: https://context7.com/ruby-i18n/ruby-cldr/llms.txt

This section covers exporting CLDR data. You can export all locales and components, specific locales and components, or filter by minimum draft status.

```APIDOC
## Export CLDR Data

### Description
Export CLDR data in various formats (YAML, Ruby) optimized for the I18n framework. Supports exporting all or specific locales and components, and filtering by draft status.

### Method
Ruby Method Call

### Endpoint
N/A (Library Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```ruby
require 'cldr/export'
require 'cldr/draft_status'

# Export all locales and all components to default directory (./data)
Cldr::Export.export do |component, locale, output_path|
  puts "Exported #{component} for #{locale} to #{output_path}"
end

# Export specific locales and components
Cldr::Export.export(
  locales: [:de, :'fr-FR', :'en-ZA'],
  components: [:Numbers, :Plurals],
  target: './my_locale_data'
) do |component, locale, path|
  puts "Created: #{path}"
end

# Set minimum draft status
Cldr::Export.export(
  locales: [:de, :en],
  components: [:Calendars],
  minimum_draft_status: Cldr::DraftStatus::APPROVED
)
```

### Response
#### Success Response (200)

- **output_path** (string) - Path to the exported file.
- **component** (symbol) - The CLDR component exported (e.g., :Numbers).
- **locale** (string) - The locale for which the data was exported (e.g., 'de').

#### Response Example
```
Exported Numbers for de to ./data/locales/de/numbers.yml
Created: ./my_locale_data/locales/de/numbers.yml
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.