Class: Foxtail::Bundle::Resolver

Inherits:
Object
  • Object
show all
Defined in:
lib/foxtail/bundle/resolver.rb

Overview

Pattern resolution engine Corresponds to fluent-bundle/src/resolver.ts

Instance Method Summary collapse

Constructor Details

#initialize(bundle) ⇒ Resolver

Returns a new instance of Resolver.



17
 
# File 'lib/foxtail/bundle/resolver.rb', line 17

def initialize(bundle) = @bundle = bundle

Instance Method Details

#resolve_complex_pattern(elements, scope) ⇒ Object

Resolve a complex pattern (array of elements)



32
33
34
35
36
37
 
# File 'lib/foxtail/bundle/resolver.rb', line 32

def resolve_complex_pattern(elements, scope)
  # Apply bidi isolation only when use_isolating is true and pattern has multiple elements
  use_isolating = @bundle.use_isolating? && elements.size > 1

  elements.map {|element| resolve_pattern_element(element, scope, use_isolating:) }.join
end

#resolve_expression(expr, scope) ⇒ Object

Resolve expressions (variables, terms, messages, functions, etc.)



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/foxtail/bundle/resolver.rb', line 70

def resolve_expression(expr, scope)
  case expr
  when Parser::AST::StringLiteral
    expr.value.to_s
  when Parser::AST::NumberLiteral
    # Return raw numeric value, not formatted string
    expr.value
  when Parser::AST::VariableReference
    resolve_variable_reference(expr, scope)
  when Parser::AST::TermReference
    resolve_term_reference(expr, scope)
  when Parser::AST::MessageReference
    resolve_message_reference(expr, scope)
  when Parser::AST::FunctionReference
    resolve_function_call(expr, scope)
  when Parser::AST::SelectExpression
    resolve_select_expression(expr, scope)
  else
    scope.add_error("Unknown expression type: #{expr.class}")
    "{#{expr.class}}"
  end
end

#resolve_pattern(pattern, scope) ⇒ Object

Resolve a pattern with the given scope



20
21
22
23
24
25
26
27
28
29
 
# File 'lib/foxtail/bundle/resolver.rb', line 20

def resolve_pattern(pattern, scope)
  case pattern
  when String
    pattern
  when Array
    resolve_complex_pattern(pattern, scope)
  else
    raise ArgumentError, "Unexpected pattern type: #{pattern.class}"
  end
end

#resolve_pattern_element(element, scope, use_isolating: false) ⇒ Object

Resolve individual pattern elements



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/foxtail/bundle/resolver.rb', line 40

def resolve_pattern_element(element, scope, use_isolating: false)
  case element
  when String
    # Text elements are not wrapped with isolation marks
    element
  when Parser::AST::NumberLiteral
    result = resolve_expression(element, scope)
    # For numeric values in patterns, format for display
    formatted = element.precision > 0 ? format_number(result, element.precision) : result.to_s
    wrap_with_isolation(formatted, use_isolating)
  when Parser::AST::VariableReference
    # Apply implicit NUMBER/DATETIME formatting for variables at display time
    result = resolve_expression(element, scope)
    formatted = apply_implicit_function(result)
    wrap_with_isolation(format_value(formatted), use_isolating)
  when Parser::AST::FunctionReference
    # Function results are Function::Value objects that need formatting
    result = resolve_expression(element, scope)
    wrap_with_isolation(format_value(result), use_isolating)
  when Parser::AST::StringLiteral, Parser::AST::TermReference,
       Parser::AST::MessageReference, Parser::AST::SelectExpression

    result = resolve_expression(element, scope)
    wrap_with_isolation(result.to_s, use_isolating)
  else
    wrap_with_isolation(element.to_s, use_isolating)
  end
end