rack-icu4x-locale 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e9e8d904fcd52b6cff5640053e45c2d75f3cc07a4a0c9db6acfdf402853cdaf4
+  data.tar.gz: 8e1ebf2cf313f66211ae47a671e808f09a58d7de2a27b0dd47ddf3d367962893
+SHA512:
+  metadata.gz: a22beb45bcf4fa131cd12cd48b760e438e2b10719a05182388311e6cd5241486cf4c862bca0d8d72a03f2d42b604321641964e9adcd82ac931f8117246e868c8
+  data.tar.gz: c21cf1f3797a084f08b92fe9bd8d07d30b349bc454e548c6ad2aa06d0ab4e271e8c8cd106a22136e07ddf72d0a38a1999773f7435664a9edfc4f77edd7d2eece

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+## [Unreleased]
+
+## [0.5.0] - 2026-01-11
+
+### Added
+
+- Pluggable detector system for locale sources (#10)
+- Locale detection from query parameters, cookies, and Accept-Language header
+- Script-safe language negotiation using ICU4X's maximize
+- Sinatra demo application in `examples/`

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 OZAWA Sakuro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+# Rack::ICU4X::Locale
+
+Rack middleware for locale detection using ICU4X. Detects user's preferred locales from various sources (query parameters, cookies, Accept-Language header), with script-safe language negotiation.
+
+## Installation
+
+```ruby
+gem 'rack-icu4x-locale'
+```
+
+## Requirements
+
+- Ruby 3.2+
+- Rack 3.0+
+
+## Usage
+
+### Basic (Accept-Language header only)
+
+```ruby
+use Rack::ICU4X::Locale, locales: %w[en ja de fr]
+
+run ->(env) {
+  locales = env["rack.icu4x.locale"]
+  [200, {}, ["Locale: #{locales.first}"]]
+}
+```
+
+### With Multiple Detectors
+
+```ruby
+use Rack::ICU4X::Locale,
+  locales: %w[en ja de fr],
+  detectors: [
+    {query: "lang"},      # ?lang=ja
+    {cookie: "locale"},   # Cookie: locale=ja
+    :header               # Accept-Language header
+  ],
+  default: "en"           # optional: fallback locale when no match
+```
+
+### With Custom Detector
+
+```ruby
+use Rack::ICU4X::Locale,
+  locales: %w[en ja de fr],
+  detectors: [
+    ->(env) { env["rack.session"]&.[]("locale") },
+    :header
+  ]
+```
+
+## Detector Types
+
+| Type | Example | Description |
+|------|---------|-------------|
+| `:header` | `Accept-Language: ja` | Accept-Language header |
+| `{cookie: "name"}` | `Cookie: name=ja` | Cookie value |
+| `{query: "param"}` | `?param=ja` | Query string parameter |
+| `Proc` | `->(env) { ... }` | Custom detection logic |
+
+## Documentation
+
+See [doc/specification.md](doc/specification.md) for detailed specification.
+
+## Demo
+
+```bash
+cd examples
+bundle install
+bundle exec rackup
+```
+
+Open http://localhost:9292
+
+## License
+
+MIT License. See [LICENSE.txt](LICENSE.txt).

data/lib/rack/icu4x/locale/detector/cookie.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rack
+  module ICU4X
+    class Locale
+      module Detector
+        # Detects locale from a cookie value.
+        #
+        # @example With default cookie name
+        #   detector = Cookie.new
+        #   env = { "HTTP_COOKIE" => "locale=ja" }
+        #   detector.call(env) # => "ja"
+        #
+        # @example With custom cookie name
+        #   detector = Cookie.new("user_locale")
+        #   env = { "HTTP_COOKIE" => "user_locale=en" }
+        #   detector.call(env) # => "en"
+        class Cookie
+          DEFAULT_NAME = "locale"
+          private_constant :DEFAULT_NAME
+
+          # @param name [String] Cookie name to read locale from
+          def initialize(name=DEFAULT_NAME)
+            @name = name
+          end
+
+          # @param env [Hash] Rack environment
+          # @return [String, nil] Locale from cookie, or nil if not present
+          def call(env)
+            cookies = ::Rack::Utils.parse_cookies(env)
+            locale = cookies[@name]
+            return nil if locale.nil? || locale.empty?
+
+            locale
+          end
+
+          private attr_reader :name
+        end
+      end
+    end
+  end
+end

data/lib/rack/icu4x/locale/detector/header.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Rack
+  module ICU4X
+    class Locale
+      module Detector
+        # Detects locales from the Accept-Language HTTP header.
+        #
+        # Returns locales sorted by quality value in descending order.
+        #
+        # @example
+        #   detector = Header.new
+        #   env = { "HTTP_ACCEPT_LANGUAGE" => "ja,en;q=0.9,de;q=0.8" }
+        #   detector.call(env) # => ["ja", "en", "de"]
+        class Header
+          # @param env [Hash] Rack environment
+          # @return [Array<String>, nil] Locales sorted by quality value, or nil if header is missing
+          def call(env)
+            header = env["HTTP_ACCEPT_LANGUAGE"]
+            return nil if header.nil? || header.empty?
+
+            parse_accept_language(header)
+          end
+
+          private def parse_accept_language(header)
+            header.split(",")
+              .map {|part| parse_entry(part) }
+              .sort_by {|_, quality| -quality }
+              .map(&:first)
+          end
+
+          private def parse_entry(part)
+            locale, quality = part.strip.split(";q=")
+            [locale.strip, Float(quality || "1")]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/icu4x/locale/detector/query.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Rack
+  module ICU4X
+    class Locale
+      module Detector
+        # Detects locale from a query string parameter.
+        #
+        # @example With default parameter name
+        #   detector = Query.new
+        #   env = Rack::MockRequest.env_for("/?locale=ja")
+        #   detector.call(env) # => "ja"
+        #
+        # @example With custom parameter name
+        #   detector = Query.new("lang")
+        #   env = Rack::MockRequest.env_for("/?lang=en")
+        #   detector.call(env) # => "en"
+        class Query
+          DEFAULT_PARAM = "locale"
+          private_constant :DEFAULT_PARAM
+
+          # @param param [String] Query parameter name to read locale from
+          def initialize(param=DEFAULT_PARAM)
+            @param = param
+          end
+
+          # @param env [Hash] Rack environment
+          # @return [String, nil] Locale from query parameter, or nil if not present
+          def call(env)
+            query_string = env["QUERY_STRING"]
+            return nil if query_string.nil? || query_string.empty?
+
+            params = ::Rack::Utils.parse_query(query_string)
+            locale = params[@param]
+            return nil if locale.nil? || locale.empty?
+
+            locale
+          end
+
+          private attr_reader :param
+        end
+      end
+    end
+  end
+end

data/lib/rack/icu4x/locale/detector.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Rack
+  module ICU4X
+    class Locale
+      # Factory module for building detector instances from various specification formats.
+      #
+      # Detectors are responsible for extracting locale preferences from the Rack environment.
+      # All detectors respond to `#call(env)` and return:
+      # - String: single locale (e.g., "ja")
+      # - Array<String>: multiple locales in preference order (e.g., ["ja", "en"])
+      # - nil: no locale detected
+      #
+      # @example Building detectors from different specification formats
+      #   Detector.build(:header)                    # => Detector::Header.new
+      #   Detector.build({ cookie: "locale" })       # => Detector::Cookie.new("locale")
+      #   Detector.build(->(env) { "ja" })           # => the Proc itself
+      module Detector
+        class InvalidSpecificationError < Error; end
+
+        INFLECTOR = Zeitwerk::Inflector.new
+        private_constant :INFLECTOR
+
+        # Build a detector from various specification formats.
+        #
+        # @param spec [Symbol, Hash, Proc, #call] Detector specification
+        # @return [#call] Detector instance responding to #call(env)
+        # @raise [InvalidSpecificationError] if the specification is invalid
+        def self.build(spec)
+          case spec
+          when Symbol then build_from_symbol(spec)
+          when Hash then build_from_hash(spec)
+          when Proc then spec
+          else
+            validate_callable!(spec)
+            spec
+          end
+        end
+
+        private_class_method def self.build_from_symbol(symbol)
+          class_name = INFLECTOR.camelize(symbol.to_s, nil)
+          const_get(class_name).new
+        rescue NameError
+          raise InvalidSpecificationError, "Unknown detector: #{symbol.inspect}"
+        end
+
+        private_class_method def self.build_from_hash(hash)
+          raise InvalidSpecificationError, "Hash must have exactly one key" unless hash.size == 1
+
+          type, arg = hash.first
+          class_name = INFLECTOR.camelize(type.to_s, nil)
+          const_get(class_name).new(arg)
+        rescue NameError
+          raise InvalidSpecificationError, "Unknown detector type: #{type.inspect}"
+        end
+
+        private_class_method def self.validate_callable!(obj)
+          return if obj.respond_to?(:call)
+
+          raise InvalidSpecificationError, "Detector must respond to #call: #{obj.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/rack/icu4x/locale/negotiator.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Rack
+  module ICU4X
+    class Locale
+      # Performs script-safe language negotiation using ICU4X's maximize.
+      #
+      # Matches requested locales against available locales, respecting script differences
+      # to avoid politically sensitive fallbacks (e.g., zh-TW won't match zh-CN).
+      #
+      # @example
+      #   locales = %w[en-US en-GB ja].map { |s| ICU4X::Locale.parse(s) }
+      #   negotiator = Rack::ICU4X::Locale::Negotiator.new(locales)
+      #   negotiator.negotiate(%w[en-AU ja-JP])  # => ["en-US", "ja"]
+      class Negotiator
+        # @param available_locales [Array<ICU4X::Locale>] List of available locales
+        def initialize(available_locales)
+          @available = build_available_index(available_locales)
+        end
+
+        # Negotiate locales, returning all matches in preference order.
+        #
+        # @param requested_locales [Array<String>] Requested locale identifiers in preference order
+        # @yield [String] Invalid locale string that could not be parsed
+        # @return [Array<String>] Matched locale identifiers
+        def negotiate(requested_locales)
+          matched = []
+          remaining = @available.dup
+
+          requested_locales.each do |req_str|
+            req_max = maximize_locale(req_str)
+
+            # 1. Exact match (language + script + region)
+            if (found = find_exact_match(remaining, req_max))
+              matched << found[:original]
+              remaining.delete(found)
+              next
+            end
+
+            # 2. Language + Script match (ignore region)
+            #    CRITICAL: Script MUST match to avoid politically sensitive fallbacks
+            if (found = find_lang_script_match(remaining, req_max))
+              matched << found[:original]
+              remaining.delete(found)
+            end
+          rescue
+            yield req_str if block_given?
+          end
+
+          matched
+        end
+
+        private def build_available_index(locales)
+          locales.map do |locale|
+            maximized = locale.maximize
+            {
+              original: locale.to_s,
+              locale:,
+              maximized:,
+              language: maximized.language,
+              script: maximized.script,
+              region: maximized.region
+            }
+          end
+        end
+
+        private def maximize_locale(locale_str) = ::ICU4X::Locale.parse(locale_str).maximize
+
+        private def find_exact_match(candidates, req_max)
+          candidates.find do |entry|
+            entry[:language] == req_max.language &&
+              entry[:script] == req_max.script &&
+              entry[:region] == req_max.region
+          end
+        end
+
+        private def find_lang_script_match(candidates, req_max)
+          candidates.find do |entry|
+            entry[:language] == req_max.language &&
+              entry[:script] == req_max.script
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/icu4x/locale/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Rack
+  module ICU4X
+    class Locale
+      VERSION = "0.5.0"
+      public_constant :VERSION
+    end
+  end
+end

data/lib/rack/icu4x/locale.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "icu4x"
+require "rack"
+require "zeitwerk"
+require_relative "locale/version"
+
+module Rack
+  module ICU4X
+    # Rack middleware that detects user's preferred locales from various sources.
+    #
+    # Uses ICU4X's maximize for script-safe language negotiation that respects
+    # script boundaries (e.g., zh-TW/Hant will NOT match zh-CN/Hans).
+    #
+    # @example Basic usage (Accept-Language header only)
+    #   use Rack::ICU4X::Locale, locales: %w[en ja]
+    #
+    # @example With multiple detectors
+    #   use Rack::ICU4X::Locale,
+    #     locales: %w[en ja],
+    #     detectors: [{ query: "lang" }, { cookie: "locale" }, :header]
+    #
+    # @example With custom detector
+    #   use Rack::ICU4X::Locale,
+    #     locales: %w[en ja],
+    #     detectors: [->(env) { env["rack.session"]&.[]("locale") }, :header]
+    class Locale
+      Zeitwerk::Loader.new.tap do |loader|
+        loader.push_dir("#{__dir__}/locale", namespace: Rack::ICU4X::Locale)
+        loader.ignore("#{__dir__}/locale/version.rb")
+        loader.setup
+      end
+
+      ENV_KEY = "rack.icu4x.locale"
+      public_constant :ENV_KEY
+
+      DEFAULT_DETECTORS = [:header].freeze
+      public_constant :DEFAULT_DETECTORS
+
+      class Error < StandardError; end
+
+      # @param app [#call] The Rack application
+      # @param locales [Array<String, ICU4X::Locale>] List of available locales
+      # @param detectors [Array] Detector specifications (optional, default: [:header])
+      # @param default [String, ICU4X::Locale, nil] Default locale when no match is found (optional)
+      def initialize(app, locales:, detectors: DEFAULT_DETECTORS, default: nil)
+        @app = app
+        @locales = locales.map {|locale| normalize_locale(locale) }
+        @detectors = build_detectors(detectors)
+        @default = default && normalize_locale(default)
+        validate_default_in_locales!
+        @negotiator = Negotiator.new(@locales)
+      end
+
+      # @param env [Hash] Rack environment
+      # @return [Array] Response from the wrapped application
+      def call(env)
+        env[ENV_KEY] = detect_locales(env)
+        @app.call(env)
+      end
+
+      private def validate_default_in_locales!
+        return unless @default
+        return if @locales.include?(@default)
+
+        raise Error, "default #{@default.to_s.inspect} is not in available locales"
+      end
+
+      private def build_detectors(specs)
+        effective_specs = specs.empty? ? DEFAULT_DETECTORS : specs
+        effective_specs.map {|spec| Detector.build(spec) }
+      end
+
+      private def detect_locales(env)
+        result = try_detectors(env)
+        result.empty? && @default ? [@default] : result
+      end
+
+      private def try_detectors(env)
+        @detectors.each do |detector|
+          raw = detector.call(env)
+          next if raw.nil?
+
+          requested = Array(raw)
+          matched = @negotiator.negotiate(requested) {|invalid_locale|
+            log_invalid_locale(env, invalid_locale)
+          }
+          return matched.map {|locale| ::ICU4X::Locale.parse(locale) } unless matched.empty?
+        end
+        []
+      end
+
+      private def normalize_locale(locale) = locale.is_a?(::ICU4X::Locale) ? locale : ::ICU4X::Locale.parse(locale)
+
+      private def log_invalid_locale(env, locale)
+        message = "Ignored invalid locale: #{locale}"
+        if env["rack.logger"]
+          env["rack.logger"].warn(message)
+        else
+          env["rack.errors"]&.puts(message)
+        end
+      end
+    end
+  end
+end

data/sig/rack/icu4x/locale/detector/cookie.rbs

@@ -0,0 +1,20 @@
+module Rack
+  module ICU4X
+    class Locale
+      module Detector
+        class Cookie
+          DEFAULT_NAME: String
+
+          @name: String
+
+          def initialize: (?String name) -> void
+          def call: (Hash[String, untyped] env) -> String?
+
+          private
+
+          attr_reader name: String
+        end
+      end
+    end
+  end
+end

data/sig/rack/icu4x/locale/detector/header.rbs

@@ -0,0 +1,17 @@
+module Rack
+  module ICU4X
+    class Locale
+      module Detector
+        class Header
+          def initialize: () -> void
+          def call: (Hash[String, untyped] env) -> Array[String]?
+
+          private
+
+          def parse_accept_language: (String header) -> Array[String]
+          def parse_entry: (String part) -> [String, Float]
+        end
+      end
+    end
+  end
+end

data/sig/rack/icu4x/locale/detector/query.rbs

@@ -0,0 +1,20 @@
+module Rack
+  module ICU4X
+    class Locale
+      module Detector
+        class Query
+          DEFAULT_PARAM: String
+
+          @param: String
+
+          def initialize: (?String param) -> void
+          def call: (Hash[String, untyped] env) -> String?
+
+          private
+
+          attr_reader param: String
+        end
+      end
+    end
+  end
+end

data/sig/rack/icu4x/locale/detector.rbs

@@ -0,0 +1,27 @@
+module Rack
+  module ICU4X
+    class Locale
+      module Detector
+        class InvalidSpecificationError < Error
+        end
+
+        INFLECTOR: Zeitwerk::Inflector
+
+        type detector_result = String | Array[String] | nil
+        type detector_spec = Symbol | Hash[Symbol, String] | ^(Hash[String, untyped]) -> detector_result | _Detector
+
+        def self.build: (detector_spec spec) -> _Detector
+
+        private
+
+        def self.build_from_symbol: (Symbol symbol) -> _Detector
+        def self.build_from_hash: (Hash[Symbol, String] hash) -> _Detector
+        def self.validate_callable!: (untyped obj) -> void
+      end
+    end
+  end
+end
+
+interface _Detector
+  def call: (Hash[String, untyped] env) -> (String | Array[String] | nil)
+end

data/sig/rack/icu4x/locale/negotiator.rbs

@@ -0,0 +1,29 @@
+module Rack
+  module ICU4X
+    class Locale
+      class Negotiator
+        type available_entry = {
+          original: String,
+          locale: ICU4X::Locale,
+          maximized: ICU4X::Locale,
+          language: String,
+          script: String,
+          region: String
+        }
+
+        @available: Array[available_entry]
+
+        def initialize: (Array[ICU4X::Locale] available_locales) -> void
+
+        def negotiate: (Array[String] requested_locales) ?{ (String) -> void } -> Array[String]
+
+        private
+
+        def build_available_index: (Array[ICU4X::Locale] locales) -> Array[available_entry]
+        def maximize_locale: (String locale_str) -> ICU4X::Locale
+        def find_exact_match: (Array[available_entry] candidates, ICU4X::Locale req_max) -> available_entry?
+        def find_lang_script_match: (Array[available_entry] candidates, ICU4X::Locale req_max) -> available_entry?
+      end
+    end
+  end
+end

data/sig/rack/icu4x/locale.rbs

@@ -0,0 +1,41 @@
+module Rack
+  module ICU4X
+    class Locale
+      VERSION: String
+      ENV_KEY: String
+      DEFAULT_DETECTORS: Array[Symbol]
+
+      class Error < StandardError
+      end
+
+      type locale_input = String | ICU4X::Locale
+
+      @app: _RackApp
+      @locales: Array[ICU4X::Locale]
+      @detectors: Array[_Detector]
+      @default: ICU4X::Locale?
+      @negotiator: Negotiator
+
+      def initialize: (
+        _RackApp app,
+        locales: Array[locale_input],
+        ?detectors: Array[Detector::detector_spec],
+        ?default: locale_input?
+      ) -> void
+      def call: (Hash[String, untyped] env) -> [Integer, Hash[String, String], _ToA[String]]
+
+      private
+
+      def validate_default_in_locales!: () -> void
+      def build_detectors: (Array[Detector::detector_spec] specs) -> Array[_Detector]
+      def detect_locales: (Hash[String, untyped] env) -> Array[ICU4X::Locale]
+      def try_detectors: (Hash[String, untyped] env) -> Array[ICU4X::Locale]
+      def normalize_locale: (locale_input locale) -> ICU4X::Locale
+      def log_invalid_locale: (Hash[String, untyped] env, String locale) -> void
+    end
+  end
+end
+
+interface _RackApp
+  def call: (Hash[String, untyped] env) -> [Integer, Hash[String, String], _ToA[String]]
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: rack-icu4x-locale
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- OZAWA Sakuro
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: icu4x
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+description: rack-icu4x-locale
+email:
+- 10973+sakuro@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/rack/icu4x/locale.rb
+- lib/rack/icu4x/locale/detector.rb
+- lib/rack/icu4x/locale/detector/cookie.rb
+- lib/rack/icu4x/locale/detector/header.rb
+- lib/rack/icu4x/locale/detector/query.rb
+- lib/rack/icu4x/locale/negotiator.rb
+- lib/rack/icu4x/locale/version.rb
+- sig/rack/icu4x/locale.rbs
+- sig/rack/icu4x/locale/detector.rbs
+- sig/rack/icu4x/locale/detector/cookie.rbs
+- sig/rack/icu4x/locale/detector/header.rbs
+- sig/rack/icu4x/locale/detector/query.rbs
+- sig/rack/icu4x/locale/negotiator.rbs
+homepage: https://github.com/sakuro/rack-icu4x-locale
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sakuro/rack-icu4x-locale
+  source_code_uri: https://github.com/sakuro/rack-icu4x-locale.git
+  changelog_uri: https://github.com/sakuro/rack-icu4x-locale/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: rack-icu4x-locale
+test_files: []