require 'parsanol'

class MyParser < Parsanol::Parser
  rule(:keyword) { str('if') | str('while') }
  rule(:expression) { keyword >> str('(') >> expression >> str(')') }
  root(:expression)
end

parser = MyParser.new
result = parser.parse('if(x)')

begin
  parser.parse('invalid input')
rescue Parsanol::ParseFailed => e
  puts e.message
  # => "Expected 'if' at line 1 char 1."
end

class MyTransform < Parsanol::Transform
  rule(keyword: simple(:k)) { KeywordNode.new(k) }
  rule(expression: subtree(:e)) { ExpressionNode.new(e) }
end

ast = MyTransform.new.apply(parse_tree)

# Parse returns results with position info
result = parser.parse("hello world", mode: :native)
name = result[:name]

# Access the value
name.to_s     # => "hello"

# Access position information
name.offset   # => 0 (byte offset in original input)
name.length   # => 5
name.line_and_column  # => [1, 1] (1-indexed)

# Compare with strings (Slice compares by content)
name == "hello"  # => true

# Extract from original source
name.extract_from(input)  # => "hello"

# Gemfile
- gem 'parslet'
+ gem 'parsanol'

# No changes needed!
require 'parslet'  # Parsanol aliases itself

class MyParser < Parslet::Parser
  rule(:number) { match('[0-9]').repeat(1) }
  root(:number)
end

parser = MyParser.new
parser.parse('123')  # Works exactly the same

result = parser.parse(input, mode: :native)  # mode is optional, :native is default

# Low-level API: Direct Rust access, String keys
grammar = Parsanol::Native.serialize_grammar(parser.root)
result = Parsanol::Native.parse_to_ruby_objects(grammar, input)
# Returns: { "name" => Slice("hello", offset: 0, length: 5) }

# High-level ZeroCopy: Include module for direct Ruby objects
class FastParser < Parsanol::Parser
  include Parsanol::ZeroCopy

  rule(:number) { match('[0-9]').repeat(1) }
  root(:number)

  output_types(number: MyNumberClass)  # Map to Ruby classes
end

parser = FastParser.new
expr = parser.parse("42")  # Returns MyNumberClass instance directly

require 'parsanol/parslet'

include Parsanol::Parslet

# Basic capture
parser = str('hello').capture(:greeting)
result = parser.parse("hello")
puts result[:greeting].to_s  # => "hello"

# Multiple captures - parse key=value pairs
kv_parser = match('[a-z]+').capture(:key) >>
              str('=') >>
              match('[a-zA-Z0-9]+').capture(:value)

result = kv_parser.parse("name=Alice")
puts result[:key].to_s    # => "name"
puts result[:value].to_s  # => "Alice"

# Without scope: inner captures leak out
parser = str('a').capture(:temp) >> str('b') >> str('c').capture(:temp)

# With scope: inner captures are discarded
parser = str('prefix').capture(:outer) >>
         scope { str('inner').capture(:inner) } >>
         str('suffix').capture(:outer_end)

result = parser.parse("prefix inner suffix")
puts result[:inner]  # => nil (discarded)
puts result[:outer]  # => "prefix"

# Type-driven value parsing
class TypeParser < Parsanol::Parser
  include Parsanol::Parslet

  rule(:type) { match('[a-z]+').capture(:type) }
  rule(:value) do
    dynamic do |ctx|
      case ctx[:type].to_s
      when 'int' then match('\d+')
      when 'str' then match('[a-z]+')
      when 'bool' then str('true') | str('false')
      else match('[a-z]+')
      end.capture(:value)
    end
  end
  rule(:declaration) { type >> str(':') >> match('[a-z]+').capture(:name) >> str('=') >> value }
  root :declaration
end

parser = TypeParser.new
result = parser.parse("int:count=42")
puts result[:type].to_s   # => "int"
puts result[:value].to_s  # => "42"

atom = Parsanol.exp("'a' +")

# Ruby parsing
atom.parse('aaa')

# Rust-accelerated parsing (if native extension available)
grammar = Parsanol::Native.serialize_grammar(atom)
Parsanol::Native.parse_to_ruby_objects(grammar, 'aaa')