foxtail-tools 0.5.0

data/lib/foxtail/syntax/parser/ast/comment.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Regular comment node in FTL syntax (# comment)
+        class Comment < BaseComment
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/function_reference.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents function calls with optional arguments
+        class FunctionReference < SyntaxNode
+          attr_accessor :id
+          attr_accessor :arguments
+
+          def initialize(id, arguments=nil)
+            super()
+            @id = id
+            @arguments = arguments
+          end
+
+          def children = [id, arguments].compact
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/group_comment.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Group comment node in FTL syntax (## group comment)
+        class GroupComment < BaseComment
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/identifier.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents identifiers used for messages, terms, attributes, and function names
+        class Identifier < SyntaxNode
+          attr_accessor :name
+
+          def initialize(name)
+            super()
+            @name = name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/junk.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents unparseable content with associated error annotations
+        class Junk < SyntaxNode
+          attr_accessor :content
+          attr_accessor :annotations
+
+          def initialize(content, annotations=[])
+            super()
+            @content = content
+            @annotations = annotations
+          end
+
+          def children = annotations
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/message.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents a Fluent message with an identifier, optional value pattern,
+        # attributes, and an optional comment
+        class Message < SyntaxNode
+          attr_accessor :id
+          attr_accessor :value
+          attr_accessor :attributes
+          attr_accessor :comment
+
+          def initialize(id, value=nil, attributes=[], comment=nil)
+            super()
+            @id = id
+            @value = value
+            @attributes = attributes
+            @comment = comment
+          end
+
+          def children = [id, value, *attributes, comment].compact
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/message_reference.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents references to messages with optional attribute access
+        class MessageReference < SyntaxNode
+          attr_accessor :id
+          attr_accessor :attribute
+
+          def initialize(id, attribute=nil)
+            super()
+            @id = id
+            @attribute = attribute
+          end
+
+          def children = [id, attribute].compact
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/named_argument.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents named arguments in function calls (e.g., arg: value)
+        class NamedArgument < SyntaxNode
+          attr_accessor :name
+          attr_accessor :value
+
+          def initialize(name, value)
+            super()
+            @name = name
+            @value = value
+          end
+
+          def children = [name, value]
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/number_literal.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents numeric literals (integers and floats)
+        class NumberLiteral < BaseLiteral
+          # Parse the number literal value and return as a Hash
+          # @return [Hash] Hash containing the parsed numeric value
+          def parse
+            value_str = @value
+
+            if value_str.include?(".")
+              {value: Float(value_str)}
+            else
+              {value: Integer(value_str, 10)}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/pattern.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents a message or term value pattern consisting of text elements
+        # and placeables (expressions within braces)
+        class Pattern < SyntaxNode
+          attr_accessor :elements
+
+          def initialize(elements)
+            super()
+            @elements = elements
+          end
+
+          def children = elements
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/placeable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents expressions within braces {} in a pattern that are evaluated at runtime
+        class Placeable < SyntaxNode
+          attr_accessor :expression
+
+          def initialize(expression)
+            super()
+            @expression = expression
+          end
+
+          def children = [expression]
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/resource.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents a Fluent resource containing messages, terms, and comments
+        # This is the root node of a parsed Fluent file
+        class Resource < SyntaxNode
+          attr_accessor :body
+
+          def initialize(body=[])
+            super()
+            @body = body
+          end
+
+          def children = body
+
+          # Iterate over Message entries only
+          # @yield [Message] each message entry
+          # @return [Enumerator] if no block given
+          # @return [self] if block given
+          def each_message(&block)
+            return enum_for(__method__) unless block
+
+            body.each {|entry| yield(entry) if entry.is_a?(Message) }
+            self
+          end
+
+          # Iterate over Term entries only
+          # @yield [Term] each term entry
+          # @return [Enumerator] if no block given
+          # @return [self] if block given
+          def each_term(&block)
+            return enum_for(__method__) unless block
+
+            body.each {|entry| yield(entry) if entry.is_a?(Term) }
+            self
+          end
+
+          # Iterate over Message and Term entries (excludes comments and junk)
+          # @yield [Message, Term] each message or term entry
+          # @return [Enumerator] if no block given
+          # @return [self] if block given
+          def each_entry(&block)
+            return enum_for(__method__) unless block
+
+            body.each {|entry| yield(entry) if entry.is_a?(Message) || entry.is_a?(Term) }
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/resource_comment.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Resource comment node in FTL syntax (### resource comment)
+        class ResourceComment < BaseComment
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/select_expression.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents select expressions for conditional message variants
+        class SelectExpression < SyntaxNode
+          attr_accessor :selector
+          attr_accessor :variants
+
+          def initialize(selector, variants)
+            super()
+            @selector = selector
+            @variants = variants
+          end
+
+          def children = [selector, *variants]
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/span.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents a source code span with start and end positions
+        # Used to track the location of AST nodes in the original source text
+        class Span < BaseNode
+          attr_accessor :start
+          attr_accessor :end
+
+          def initialize(start_pos, end_pos)
+            super()
+            @start = start_pos
+            @end = end_pos
+          end
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/string_literal.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents quoted string literals with escape sequence processing
+        class StringLiteral < BaseLiteral
+          # Parse the string literal value, processing escape sequences
+          # Handles backslash escapes, Unicode escapes (uHHHH, UHHHHHH), and validates Unicode scalar values
+          # @return [Hash] Hash containing the parsed string value
+          def parse
+            # Backslash backslash, backslash double quote, uHHHH, UHHHHHH.
+            known_escapes = /(?:\\\\|\\"|\\u(\h{4})|\\U(\h{6}))/
+
+            escaped_value = @value.gsub(known_escapes) {|match|
+              codepoint4 = $1
+              codepoint6 = $2
+
+              case match
+              when "\\\\"
+                "\\"
+              when '\\"'
+                '"'
+              else
+                codepoint = (codepoint4 || codepoint6).to_i(16)
+                if codepoint <= 0xd7ff || 0xe000 <= codepoint
+                  # It's a Unicode scalar value.
+                  codepoint.chr(Encoding::UTF_8)
+                else
+                  # Escape sequences representing surrogate code points are
+                  # well-formed but invalid in Fluent. Replace them with U+FFFD
+                  # REPLACEMENT CHARACTER.
+                  "\uFFFD"
+                end
+              end
+            }
+
+            {value: escaped_value}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/syntax_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Base class for AST nodes that can have span information
+        # Extends BaseNode with source position tracking capabilities
+        class SyntaxNode < BaseNode
+          attr_accessor :span
+
+          # Add span information to this syntax node
+          # @param start_pos [Integer] Starting position in the source
+          # @param end_pos [Integer] Ending position in the source
+          def add_span(start_pos, end_pos)
+            @span = Span.new(start_pos, end_pos)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/term.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents a Fluent term with an identifier, value pattern,
+        # optional attributes, and an optional comment
+        class Term < SyntaxNode
+          attr_accessor :id
+          attr_accessor :value
+          attr_accessor :attributes
+          attr_accessor :comment
+
+          def initialize(id, value, attributes=[], comment=nil)
+            super()
+            @id = id
+            @value = value
+            @attributes = attributes
+            @comment = comment
+          end
+
+          def children = [id, value, *attributes, comment].compact
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/term_reference.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents references to terms with optional attribute access and arguments
+        class TermReference < SyntaxNode
+          attr_accessor :id
+          attr_accessor :attribute
+          attr_accessor :arguments
+
+          def initialize(id, attribute=nil, arguments=nil)
+            super()
+            @id = id
+            @attribute = attribute
+            @arguments = arguments
+          end
+
+          def children = [id, attribute, arguments].compact
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/text_element.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents plain text content within a pattern
+        class TextElement < SyntaxNode
+          attr_accessor :value
+
+          def initialize(value)
+            super()
+            @value = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/variable_reference.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents references to variables passed as arguments (e.g., $variable)
+        class VariableReference < SyntaxNode
+          attr_accessor :id
+
+          def initialize(id)
+            super()
+            @id = id
+          end
+
+          def children = [id]
+        end
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/ast/variant.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      module AST
+        # Represents individual variants within select expressions
+        class Variant < SyntaxNode
+          attr_accessor :key
+          attr_accessor :value
+          attr_accessor :default
+
+          def initialize(key, value, default: false)
+            super()
+            @key = key
+            @value = value
+            @default = default
+          end
+
+          def children = [key, value]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      # Namespace module for abstract syntax tree node classes
+      # With Zeitwerk, individual node classes are automatically loaded when referenced
+      module AST
+      end
+    end
+  end
+end

data/lib/foxtail/syntax/parser/parse_error.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Foxtail
+  module Syntax
+    class Parser
+      # Parse error with detailed error codes and messages
+      class ParseError < Foxtail::Syntax::Error
+        # @return [String] Error code (e.g., "E0001", "E0002")
+        attr_reader :code
+        # @return [Array] Additional arguments for error message formatting
+        attr_reader :args
+
+        # @param code [String] Error code
+        # @param args [Array] Additional arguments for error message formatting
+        def initialize(code, *args)
+          @code = code
+          @args = args
+          super(error_message(code, args))
+        end
+
+        private def error_message(code, args)
+          case code
+          when "E0001"
+            "Generic error"
+          when "E0002"
+            "Expected an entry start"
+          when "E0003"
+            token = args[0]
+            "Expected token: \"#{token}\""
+          when "E0004"
+            range = args[0]
+            "Expected a character from range: \"#{range}\""
+          when "E0005"
+            id = args[0]
+            "Expected message \"#{id}\" to have a value or attributes"
+          when "E0006"
+            id = args[0]
+            "Expected term \"-#{id}\" to have a value"
+          when "E0007"
+            "Expected a keyword"
+          when "E0008"
+            "The callee has to be an upper-case identifier or a term"
+          when "E0009"
+            "The argument name has to be a simple identifier"
+          when "E0010"
+            "Expected one of the variants to be marked as default (*)"
+          when "E0011"
+            "Expected at least one variant after \"->\""
+          when "E0012"
+            "Expected value"
+          when "E0013"
+            "Expected a variant key"
+          when "E0014"
+            "Expected literal"
+          when "E0015"
+            "Only one variant can be marked as default (*)"
+          when "E0016"
+            "Message references cannot be used as selectors"
+          when "E0017"
+            "Terms cannot be used as selectors"
+          when "E0018"
+            "Attributes of messages cannot be used as selectors"
+          when "E0019"
+            "Attributes of terms cannot be used as placeables"
+          when "E0020"
+            "Unterminated string expression"
+          when "E0021"
+            "Positional arguments must not follow named arguments"
+          when "E0022"
+            "Named arguments must be unique"
+          when "E0023"
+            "Expected an option list"
+          when "E0024"
+            "Expected a keyword argument"
+          when "E0025"
+            arg = args[0]
+            "Unknown escape sequence: \\#{arg}."
+          when "E0026"
+            sequence = args[0]
+            "Invalid Unicode escape sequence: #{sequence}."
+          when "E0027"
+            "Unbalanced closing brace in TextElement."
+          when "E0028"
+            "Expected an inline expression"
+          when "E0029"
+            "Nested placeables are not allowed"
+          else
+            "Unknown error: #{code}"
+          end
+        end
+      end
+    end
+  end
+end