foxtail-runtime 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d7c03fa078365be8892be86558075ca205acdc8cce593a18f594d85332239a87
+  data.tar.gz: df182477a72b683c9055f579d88a83d896c97a2937f506e28b4df2dc31f4d90b
+SHA512:
+  metadata.gz: 5b884a63ba415f43fc3062644d2447090ed29fb49be70c68cb807c5f9cc34861e24b96652cb7826a311b3c74e29a8cdb8066cf269a4fb9632df4d3558f570b7f
+  data.tar.gz: 15632c63f8abae557b11958be5ccd512839b3e357e9170b44afe06efd57949acedb9a26bf9bde1d06c336bd7a059f9c20c386dacea7691ebda5bb1636395b918

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+## [Unreleased]
+
+## [0.5.0] - 2026-05-08
+
+### Added
+- **Core System**
+  - Ruby implementation of Project Fluent localization system
+  - Runtime message formatting with Bundle system
+  - Pattern selection with pluralization support
+  - `Sequence` class for language fallback chains
+  - Bidi isolation support (`use_isolating` option)
+- **Formatting Features**
+  - `icu4x`-based number and date formatting
+  - Built-in functions: NUMBER() and DATETIME()
+  - Implicit NUMBER/DATETIME function calling for numeric and time variables
+- **Examples**
+  - Executable usage demonstrations in `examples/`
+### Compatibility
+- fluent.js bundle parser: 62/62 (100%)
+- Ruby: 3.3+ supported

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 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,61 @@
+# 🦊 Foxtail Runtime 🌐
+
+Runtime components for [Project Fluent](https://projectfluent.org/) localization in Ruby.
+
+## Features
+
+- Bundle parsing and runtime message formatting
+- ICU4X-based number, date/time, and plural rules formatting
+- Fluent.js-compatible runtime AST
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "foxtail-runtime"
+```
+
+Then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install foxtail-runtime
+```
+
+## Basic Usage
+
+```ruby
+require "foxtail-runtime"
+require "icu4x-data-recommended" # for locale-aware NUMBER formatting
+
+resource = Foxtail::Resource.from_string(<<~FTL)
+  hello = Hello, { $name }!
+  price = { NUMBER($amount, style: "currency", currency: "USD") }
+FTL
+
+bundle = Foxtail::Bundle.new(ICU4X::Locale.parse("en-US"))
+bundle.add_resource(resource)
+
+bundle.format("hello", name: "Alice")
+# => "Hello, Alice!"
+
+bundle.format("price", amount: 1234.5)
+# => "$1,234.5"
+```
+
+## Documentation
+
+- [Architecture](doc/architecture.md)
+- [Bundle System](doc/bundle-system.md)
+- [ICU4X Integration](doc/icu4x-integration.md)
+- [Sequence](doc/sequence.md)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/foxtail/bundle/parser/ast.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Foxtail
+  class Bundle
+    class Parser
+      # Ruby port of fluent-bundle/src/ast.ts type system
+      # Data class-based implementation for immutability and type safety
+      module AST
+        StringLiteral = Data.define(:value)
+
+        # String literal expression in Fluent patterns
+        # @!attribute value [r] [String] The string value
+        class StringLiteral
+          # @param value [#to_s] The string value (will be converted to String)
+          def initialize(value:) = super(value: value.to_s)
+        end
+
+        NumberLiteral = Data.define(:value, :precision)
+
+        # Number literal expression in Fluent patterns
+        # @!attribute value [r] [Float] The numeric value
+        # @!attribute precision [r] [Integer] Number of decimal places
+        class NumberLiteral
+          # @param value [Numeric, String] The numeric value (will be converted to Float)
+          # @param precision [Integer] Number of decimal places (default: 0)
+          def initialize(value:, precision: 0) = super(value: Float(value), precision: Integer(precision))
+        end
+
+        VariableReference = Data.define(:name)
+
+        # Variable reference expression ($variable) in Fluent patterns
+        # @!attribute name [r] [String] The variable name (without $ prefix)
+        class VariableReference
+          # @param name [#to_s] The variable name (will be converted to String)
+          def initialize(name:) = super(name: name.to_s)
+        end
+
+        TermReference = Data.define(:name, :attr, :args)
+
+        # Term reference expression (-term) in Fluent patterns
+        # @!attribute name [r] [String] The term name (without - prefix)
+        # @!attribute attr [r] [String, nil] The attribute name if accessing an attribute
+        # @!attribute args [r] [Array] Arguments passed to the term
+        class TermReference
+          # @param name [#to_s] The term name (will be converted to String)
+          # @param attr [#to_s, nil] The attribute name (default: nil)
+          # @param args [Array] Arguments passed to the term (default: [])
+          def initialize(name:, attr: nil, args: []) = super(name: name.to_s, attr: attr&.to_s, args:)
+        end
+
+        MessageReference = Data.define(:name, :attr)
+
+        # Message reference expression (message) in Fluent patterns
+        # @!attribute name [r] [String] The message identifier
+        # @!attribute attr [r] [String, nil] The attribute name if accessing an attribute
+        class MessageReference
+          # @param name [#to_s] The message identifier (will be converted to String)
+          # @param attr [#to_s, nil] The attribute name (default: nil)
+          def initialize(name:, attr: nil) = super(name: name.to_s, attr: attr&.to_s)
+        end
+
+        FunctionReference = Data.define(:name, :args)
+
+        # Function call expression (FUNCTION()) in Fluent patterns
+        # @!attribute name [r] [String] The function name (uppercase by convention)
+        # @!attribute args [r] [Array] Function arguments (positional and named)
+        class FunctionReference
+          # @param name [#to_s] The function name (will be converted to String)
+          # @param args [Array] Function arguments (default: [])
+          def initialize(name:, args: []) = super(name: name.to_s, args:)
+        end
+
+        NamedArgument = Data.define(:name, :value)
+
+        # Named argument in function calls (key: value)
+        # @!attribute name [r] [String] The argument name
+        # @!attribute value [r] The argument value expression
+        class NamedArgument
+          # @param name [#to_s] The argument name (will be converted to String)
+          # @param value The argument value expression
+          def initialize(name:, value:) = super(name: name.to_s, value:)
+        end
+
+        SelectExpression = Data.define(:selector, :variants, :star)
+
+        # Select expression for pluralization and variants
+        # @!attribute selector [r] The expression to match against
+        # @!attribute variants [r] [Array<Variant>] The variant branches
+        # @!attribute star [r] [Integer] Index of the default variant
+        class SelectExpression
+          # @param selector The expression to match against
+          # @param variants [Array<Variant>] The variant branches
+          # @param star [Integer] Index of the default variant (default: 0)
+          def initialize(selector:, variants:, star: 0) = super
+        end
+
+        # Variant for select expressions (no type field, no special initialization)
+        Variant = Data.define(:key, :value)
+
+        Message = Data.define(:id, :value, :attributes)
+
+        # Message entry in fluent-bundle compatible format
+        # @!attribute id [r] [String] The message identifier
+        # @!attribute value [r] The message pattern (String or Array)
+        # @!attribute attributes [r] [Hash, nil] Message attributes
+        class Message
+          # @param id [#to_s] The message identifier (will be converted to String)
+          # @param value The message pattern (default: nil)
+          # @param attributes [Hash, nil] Message attributes (default: nil)
+          def initialize(id:, value: nil, attributes: nil) = super(id: id.to_s, value:, attributes:)
+        end
+
+        Term = Data.define(:id, :value, :attributes)
+
+        # Term entry in fluent-bundle compatible format
+        # @!attribute id [r] [String] The term identifier (with - prefix)
+        # @!attribute value [r] The term pattern (String or Array)
+        # @!attribute attributes [r] [Hash, nil] Term attributes
+        class Term
+          # @param id [#to_s] The term identifier (- prefix will be added if missing)
+          # @param value The term pattern
+          # @param attributes [Hash, nil] Term attributes (default: nil)
+          def initialize(id:, value:, attributes: nil)
+            term_id = id.to_s
+            term_id = "-#{term_id}" unless term_id.start_with?("-")
+            super(id: term_id, value:, attributes:)
+          end
+        end
+
+        # Junk entry for unparseable content
+        # @!attribute content [r] [String] The raw unparseable content
+        # @!attribute annotations [r] [Array<Hash>] Parser annotations/errors
+        Junk = Data.define(:content, :annotations)
+
+        # Comment entry for FTL comments
+        # @!attribute content [r] [String] The comment text
+        Comment = Data.define(:content)
+
+        # Type checking helpers (following TypeScript union types)
+
+        # Check if node is a literal (string or number)
+        def self.literal?(node) = node.is_a?(StringLiteral) || node.is_a?(NumberLiteral)
+
+        # Check if node is an expression
+        def self.expression?(node)
+          return true if literal?(node)
+
+          node.is_a?(VariableReference) ||
+            node.is_a?(TermReference) ||
+            node.is_a?(MessageReference) ||
+            node.is_a?(FunctionReference) ||
+            node.is_a?(SelectExpression)
+        end
+
+        # Check if node can be a pattern element
+        def self.pattern_element?(node) = node.is_a?(String) || expression?(node)
+
+        # Check if node is a complex pattern (array of pattern elements)
+        def self.complex_pattern?(node) = node.is_a?(Array) && node.all? {|el| pattern_element?(el) }
+
+        # Check if node is any valid pattern
+        def self.pattern?(node) = node.is_a?(String) || complex_pattern?(node)
+      end
+    end
+  end
+end