Ruby Bindings

# Batch mode with tagged AST nodes
result = Parsanol::Native.parse_batch(grammar, input)

# Results preserve :repetition and :sequence tags
# This enables correct Ruby transformation for complex patterns

# Parse result
result = parser.parse("SCHEMA test;", mode: :native)
# => {:name => "test"@7}  # @7 shows byte offset

# Access the slice
slice = result[:name]
slice.to_s            # => "test" (string content)
slice.offset          # => 7 (byte position)
slice.length          # => 4
slice.line_and_column # => [1, 8] (line, column - 1-indexed)

# String comparison works
slice == "test"       # => true

# Extract from original source
slice.extract_from(input)  # => "test"
            

class Parsanol::Slice
  # Core attributes (always available, zero cost)
  def content       # String content
  def offset        # Byte offset in original input
  def length        # Length of the slice

  # Lazy computation (computed on first access, then cached)
  def line_and_column  # [line, column] tuple (1-indexed)

  # String compatibility
  def to_s          # Returns content
  def to_str        # Implicit string conversion
  def ==(other)     # Compares content with String or Slice

  # JSON serialization
  def to_json       # Returns { "value" => ..., "offset" => ..., ... }
  def as_json       # Returns hash with position info

  # Utility
  def to_span       # Returns SourceSpan object
  def extract_from(input)  # Extracts content from original input
end
            

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   INPUT     │     │  PARSANOL   │     │   OUTPUT    │
│   String    │────▶│  (Ruby)     │────▶│Slice Objects│
└─────────────┘     └─────────────┘     └─────────────┘
                          │
                    SLOW parsing
                    Pure Ruby

SPEED: 1x (baseline) - 425s (SRL benchmark)
            

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   INPUT     │     │  PARSANOL   │     │   OUTPUT    │
│   String    │────▶│  (Rust)     │────▶│Slice Objects│
└─────────────┘     └─────────────┘     └─────────────┘
                          │
                    FAST parsing
                    Position tracking included

SPEED: ~200-1300x faster depending on pattern complexity
FEATURES: Slice objects with offset, length, line, column
            

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   INPUT     │     │  PARSANOL   │     │   OUTPUT    │
│   String    │────▶│  (Rust)     │────▶│JSON + Pos   │
└─────────────┘     └─────────────┘     └─────────────┘
                          │
                    FAST parsing
                    Position inline in JSON

SPEED: ~200-1300x faster depending on pattern complexity
FORMAT: {"value": "hello", "offset": 0, "length": 5, ...}
            

# Clone and setup
git clone https://github.com/parsanol/parsanol-ruby
cd parsanol-ruby
bundle install

# Build native extension (requires Rust)
bundle exec rake compile

# Run quick benchmarks (skips large inputs)
bundle exec ruby benchmark/run_all.rb --quick

# Run all benchmarks
bundle exec ruby benchmark/run_all.rb
            

require 'parsanol/streaming'

# Configure chunk size and backtracking window
config = Parsanol::Streaming::ChunkConfig.new(
  chunk_size: 64 * 1024,  # 64 KB chunks
  window_size: 3          # Keep 3 chunks for backtracking
)

# Parse from a file
parser = Parsanol::StreamingParser.new(grammar, config)
result = parser.parse_from_file('large_file.json')

# Parse from any IO object
result = parser.parse_from_io(socket, config)
            

# Define grammar with captures
class LogParser < Parsanol::Parser
  rule(:ip) { match('\d').repeat(1,3) >> str('.') >> match('\d').repeat(1,3) >> str('.') >> match('\d').repeat(1,3) >> str('.') >> match('\d').repeat(1,3) }
  rule(:log_line) { capture(:ip, ip) >> str(' ') >> capture(:status, match('\d').repeat(3)) }
  root(:log_line)
end

# Parse large log file with streaming
config = Parsanol::Streaming::ChunkConfig.new(chunk_size: 1024 * 1024, window_size: 2)
parser = Parsanol::StreamingParser.new(LogParser.new.grammar, config)

result = parser.parse_from_file('access.log')
# Access captures from streaming parse
result.captures[:ip].each { |ip| puts ip }
            

class MyBuilder
  include Parsanol::BuilderCallbacks

  def on_rule(name, start_pos, end_pos)
    puts "Rule #{name} at #{start_pos}..#{end_pos}"
  end

  def on_capture(name, value)
    puts "Captured #{name}: #{value}"
  end
end

builder = MyBuilder.new
parser.parse_from_file('large.json', builder: builder)