grammar Delorean
  rule line
    f:formula sp? ('#' .*)? <Line>
  end

  rule formula
    sp4 i:identifier sp? '=?' sp? e:expression <ParameterDefault>
    /
    sp4 i:identifier sp? '=?' <Parameter>
    /
    sp4 i:identifier sp? '=' sp? e:expression <Formula>
    /
    n:class_name ':' sp? mod:(m:class_name_import_nested) <SubNodeNested> # FIXME: requires to be above SubNode statement, otherwise doesn't work
    /
    n:class_name ':' sp? mod:(m:class_name '::')? p:class_name <SubNode>
    /
    n:class_name ':' <BaseNode>
    /
    'import' sp n:class_name_import <Import>
  end

  rule class_name
    [A-Z] [a-zA-Z0-9_]*
  end

  rule class_name_import
    [A-Z] [a-zA-Z0-9_]* ('::' [A-Z] [a-zA-Z0-9_]*)*
  end

  # FIXME: Hacky way to skip Module::Node cases, so only Module::NestedModule::Node will pass
  rule class_name_import_nested
    [A-Z] [a-zA-Z0-9_]* (('::' [A-Z] [a-zA-Z0-9_]*) 2..)
  end

  rule elsif
    'elsif' sp? v:expression sp? 'then' sp? e1:expression sp?
  end

  rule expression
    'ERR(' sp? args:fn_args? sp? ')' <ErrorOp>
    /
    op:unary_op sp? e:expression <UnOp>
    /
    'if'        sp? v:expression sp?
    'then'      sp? e1:expression sp?
    'else'      sp? e2:expression <IfElse>
    /
    'if'        sp? v:expression sp?
    'then'      sp? e1:expression sp?
    sp? elsifs:elsif+ sp?
    'else'      sp? e2:expression <IfElsifElse>
    /
    v:getattr_exp sp? op:binary_op sp? e:expression <BinOp>
    /
    getattr_exp
  end

  rule block_args
		sp4 sp4 sp? i:identifier sp? '=?' sp1? e:expression <BlockParameterDefault>
		/
    sp4 sp4 sp? i:identifier sp? '=?' <BlockParameter>
  end
  
  rule block_formulas
    sp4 sp4 sp? i:identifier sp? '=' sp? e:expression <BlockFormula>
	end

  rule getattr_exp
    v:value dotted:dotted <GetattrExp>
    /
    value
  end

  rule dotted
    d:dot_exp d_rest:dotted? <Dotted>
  end

  rule dot_exp
    '[' sp? args:fn_args sp? ']' <IndexOp>
    /
    '(' sp? al:kw_args? sp? ')' <NodeCall>
    /
    '.' sp? i:identifier '(' sp? al:fn_args? sp? ')' b_args:block_args* expressions:block_formulas+ <BlockExpression>
    /
    '.' sp? i:identifier '(' sp? al:fn_args? sp? ')' <Call>
    /
    '&.' sp? i:identifier '(' sp? al:fn_args? sp? ')' <SafeNavigationCall>
		/
    '.' sp? i:identifier b_args:block_args* expressions:block_formulas+ <BlockExpression>
    /
    '.' sp? i:(identifier / integer) <GetAttr>
    /
    '&.' sp? i:(identifier / integer) <SafeNavigationGetAttr>
  end

  rule unpack_args
    arg0:identifier args_rest:(sp? ',' sp? args:unpack_args?)? <UnpackArgs>
  end

  rule list_expr
    '[]' <ListExpr>
    /
    '[' sp? e2:expression sp
        'for' sp args:unpack_args sp
        'in' sp e1:expression sp?
        ifexp:('if' sp e3:expression sp?)?
    ']' <ListComprehension>
    /
    '[' sp? args:fn_args sp? ']' <ListExpr>
  end

  rule set_expr
    '{-}' <SetExpr>
    /
    '{' sp? e2:expression sp
        'for' sp args:unpack_args sp
        'in' sp e1:expression sp?
        ifexp:('if' sp e3:expression sp?)?
    '}' <SetComprehension>
    /
    '{' sp? args:fn_args sp? '}' <SetExpr>
  end

  rule hash_expr
    '{}' <HashExpr>
    /
    '{' sp? el:expression sp? ':' sp? er:expression sp
        'for' sp args:unpack_args sp
        'in' sp e1:expression sp?
        ifexp:('if' sp ei:expression sp?)?
    '}' <HashComprehension>
    /
    '{' sp? args:hash_args sp? '}' <HashExpr>
  end

  # NOTE: some operations such as << have side-effects (e.g. on
  # Arrays).  So, be cautious about which opertaions are added.
  rule binary_op
    '==' / '!=' / '>=' / '<=' / '&&' / '||' / '**' /
    '>'  / '<'  / '+' / '-' / '*' / '/' / '%' /
    '&'  / '^'  / '|' / 'in' sp
  end

  rule unary_op
    '!' / '-'
  end

  rule value
    decimal                                             /
    integer                                             /
    string                                              /
    boolean                                             /
    nil_val                                             /
    sup                                                 /
    identifier                                          /
    self                                                /
    list_expr                                           /
    set_expr                                            /
    hash_expr                                           /
    c:class_name_import <NodeAsValueNested>             / # FIXME: requires to be above NodeAsValue statement, otherwise doesn't work
    mod:(m:class_name '::')? c:class_name <NodeAsValue> /
    '(' sp? e:expression sp? ')'          <Expr>
  end

  rule fn_args
    arg0:expression args_rest:(sp? ',' sp? args:fn_args?)? <FnArgs>
  end

  rule hash_args
    splat:('**') e0:expression sp?
    ifexp:('if' sp e3:expression sp?)?
    args_rest:(sp? ',' sp? al:hash_args?)? <HashArgs>
    /
    e0:expression sp? ':' sp? e1:expression sp?
    ifexp:('if' sp e3:expression sp?)?
    args_rest:(sp? ',' sp? al:hash_args?)? <HashArgs>
  end

  rule kw_args
    splat:('**') arg0:expression sp?
    ifexp:('if' sp e3:expression sp?)?
    args_rest:(sp? ',' sp? al:kw_args?)? <KwArgs>
    /
    k:(i:identifier sp? '=' sp?)? arg0:expression sp?
    ifexp:('if' sp e3:expression sp?)?
    args_rest:(sp? ',' sp? al:kw_args?)? <KwArgs>
  end

  # rule block_args
    # '|' sp? args:unpack_args sp? '|'
  # end

  rule decimal
    i:integer '.' [0-9]+ <Literal>
  end

  rule integer
    '0' <Literal> / [1-9] [0-9]* <Literal>
  end

  rule identifier
    [a-z] [a-zA-Z0-9_]* '?'? <Identifier> /
    [_] [a-zA-Z0-9_]+ '?'? <Identifier> 
  end

  rule boolean
    'true' <Literal> / 'false' <Literal>
  end

  rule sup
    '_sup' <Sup>
  end

  rule self
    '_' <Self>
  end

  rule nil_val
    'nil' <Literal>
  end

  # and you thought python was anal about spaces?
  rule sp4
    '    '
  end

  rule sp1
    ' '
	end

  rule sp
    [\s]+
  end


  rule string
    '"' ('\"' / !'"' .)* '"' <IString>
    /
    "'" [^']* "'" <DString>
  end
end