logstash_config.peg

// Parsing rules based on https://github.com/elastic/logstash/blob/master/logstash-core/lib/logstash/config/grammar.treetop
{
    package config
}

// Parsing entry point
init =
    #{
        return c.initState()
    }
    &{
        return c.initParser()
    } conf:(
        conf:config EOF {
            return c.ret(conf)
        } / _ EOF {
            return ast.NewConfig(nil, nil, nil), nil
        }
    ) {
        return c.retConfig(conf)
    }

//  rule config
//    _ plugin_section _ (_ plugin_section)* _ <LogStash::Config::AST::Config>
//  end

// Removed _ after initial pluginSection (ps), because it is not needed.

config =
    psComment:_ ps:pluginSection pss:(
        psComment:_ ps:pluginSection {
            return c.configSection(ps, psComment)
        }
    )* footerComment:_ EOF {
        return c.config(ps, pss, psComment, footerComment)
    }

//  rule comment
//    (whitespace? "#" [^\r\n]* "\r"? "\n")+ <LogStash::Config::AST::Comment>
//  end

comment =
    (whitespace? "#" [^\r\n]* "\r"? ("\n" / EOF))+ {
      return c.comment()
    }

//  rule _
//    (comment / whitespace)* <LogStash::Config::AST::Whitespace>
//  end

_ =
    (comment / whitespace)*

// Add __ rule, which keeps compatibility, with Logstash, but allows to warn
// about comments in exceptional locations instead of just silently ignore them.

__ =
    ( (comment / whitespace)* {
        return c.str()
    } ) #{
        return c.warnComment()
    }

//  rule whitespace
//    [ \t\r\n]+ <LogStash::Config::AST::Whitespace>
//  end

whitespace =
    [ \t\r\n]+ {
      return c.whitespace()
    }

//  rule plugin_section
//    plugin_type _ "{"
//       _ (branch_or_plugin _)*
//    "}"
//    <LogStash::Config::AST::PluginSection>
//  end

// Moved _ after "{" to plugin / branch section to simplify comment handling
// Moved _ footerComment outside of ( ... )* seciont to simplify comment handling

pluginSection =
    pt:pluginType __ "{" bops:(
        bop:branchOrPlugin {
            return c.ret(bop)
        }
    )* footerComment:_ (
        "}" / &{
            return c.pushError("expect closing curly bracket")
        }
    ) {
        return c.pluginSection(pt, bops, footerComment)
    }

//   rule branch_or_plugin
//     branch / plugin
//   end

branchOrPlugin =
    branch / plugin

//   rule plugin_type
//     ("input" / "filter" / "output")
//   end

pluginType =
    "input" {
        return ast.Input, nil
    } / "filter" {
        return ast.Filter, nil
    } / "output" {
        return ast.Output, nil
    } / &{
        return c.pushError("expect plugin type (input, filter, output)")
    }

//   rule plugins
//     (plugin (_ plugin)*)?
//     <LogStash::Config::AST::Plugins>
//   end

//   rule plugin
//     name _ "{"
//       _
//       attributes:( attribute (whitespace _ attribute)*)?
//       _
//     "}"
//     <LogStash::Config::AST::Plugin>
//   end

// Moved _ after "{" inside block attributes before attribute to simplify comment handling

plugin =
    comment:_ name:name __ "{" attributes:(
        comment:_ attribute:attribute attrs:(
            whitespace comment:_ attribute:attribute {
                return c.attributeComment(attribute, comment, true)
            }
        )* {
            return c.attributes(attribute, attrs, comment)
        }
    )? footerComment:_ (
        "}" / &{
            return c.fatalError("expect closing curly bracket")
        }
    ) {
        return c.plugin(name, attributes, comment, footerComment)
    }

//   rule name
//     (
//       ([A-Za-z0-9_-]+ <LogStash::Config::AST::Name>)
//       / string
//     )
//   end

name =
    ( ([A-Za-z0-9_-]+) {
        return c.string(ast.Bareword)
    } / value:stringValue {
        return c.ret(value)
    } )

//   rule attribute
//     name _ "=>" _ value
//     <LogStash::Config::AST::Attribute>
//   end

attribute =
    name:name __ "=>" __ value:value {
        return c.attribute(name, value)
    }

//   rule value
//     plugin / bareword / string / number / array / hash
//   end

value =
    plugin / bareword / stringValue / number / array / hash / &{
        return c.pushError("invalid value")
    }

//   rule array_value
//     bareword / string / number / array / hash
//   end

arrayValue =
    bareword / stringValue / number / array / hash / &{
        return c.fatalError("invalid array value")
    }

//   rule bareword
//     [A-Za-z_] [A-Za-z0-9_]+
//     <LogStash::Config::AST::Bareword>
//   end

bareword =
    [A-Za-z_] [A-Za-z0-9_]+ {
        return c.string(ast.Bareword)
    }

//   rule double_quoted_string
//     ( '"' ( '\"' / !'"' . )* '"' <LogStash::Config::AST::String>)
//   end

doubleQuotedString =
    ( `"` ( `\"` / !`"` . )* (
        `"` / &{
            return c.fatalError("expect closing double quotes (\")")
        }
    ) ) {
        return c.enclosedValue()
    }

//   rule single_quoted_string
//     ( "'" ( "\\'" / !"'" . )* "'" <LogStash::Config::AST::String>)
//   end

singleQuotedString =
    ( `'` ( `\'` / !`'` . )* (
        `'` / &{
            return c.fatalError("expect closing single quote (')")
        }
    ) ) {
        return c.enclosedValue()
    }

//   rule string
//     double_quoted_string / single_quoted_string
//   end

stringValue =
    str:( str:doubleQuotedString {
        return c.string(ast.DoubleQuoted)
    } / str:singleQuotedString {
        return c.string(ast.SingleQuoted)
    } ) {
        return c.ret(str)
    }

//   rule regexp
//     ( '/' ( '\/' / !'/' . )* '/'  <LogStash::Config::AST::RegExp>)
//   end

regexp =
    ( `/` ( `\/` / !`/` . )* (
        `/` / &{
            return c.fatalError("expect closing slash (/) for regexp")
        }
    ) ) {
        return c.regexp()
    }

//   rule number
//     "-"? [0-9]+ ("." [0-9]*)?
//     <LogStash::Config::AST::Number>
//   end

number =
    "-"? [0-9]+ ("." [0-9]*)? {
        return c.number()
    }

//   rule array
//     "["
//     _
//     (
//       value (_ "," _ value)*
//     )?
//     _
//     "]"
//     <LogStash::Config::AST::Array>
//   end

// TODO: value should be changed to to array_value due to https://github.com/elastic/logstash/issues/6580

// Moved _ after "[" inside values infront of first value:value to simplify comment handling

array =
    "[" values:(
        comment:_ value:value values:(
            __ "," comment:_ value:value {
                return c.attributeComment(value, comment, true)
            }
        )* {
            return c.attributes(value, values, comment)
        }
    )? footerComment:_ (
        "]" / &{
            return c.fatalError("expect closing square bracket")
        }
    ) {
        return c.array(values, footerComment)
    }

//   rule hash
//     "{"
//       _
//       hashentries?
//       _
//     "}"
//     <LogStash::Config::AST::Hash>
//   end

// Moved _ after "{" to hashentry section to simplify comment handling

hash =
    "{" entries:hashentries? footerComment:_ (
        "}" / &{
            return c.fatalError("expect closing curly bracket")
        }
    ) {
        return c.hash(entries, footerComment)
    }

//   rule hashentries
//     hashentry (whitespace hashentry)*
//     <LogStash::Config::AST::HashEntries>
//   end

hashentries =
    hashentry:hashentry hashentries1:(
        whitespace hashentry:hashentry {
            return c.ret(hashentry)
        }
    )* {
        return c.hashentries(hashentry, hashentries1)
    }

//   rule hashentry
//     name:(number / bareword / string) _ "=>" _ value
//     <LogStash::Config::AST::HashEntry>
//   end

hashentry =
    comment:_ name:(number / bareword / stringValue) __ "=>" __ value:value {
        return c.hashentry(name, value, comment)
    }

// Conditions

//   rule branch
//     if (_ else_if)* (_ else)?
//     <LogStash::Config::AST::Branch>
//   end

// Added _ before ifBlock to simplify comment handling

branch =
    ifComment:_ ifBlock:ifCond elseIfBlocks:(
        eibComment:_ eib:elseIf {
                return c.elseIfComment(eib, eibComment)
            }
        )* elseBlock:(
            ebComment:_ eb:elseCond {
                return c.elseComment(eb, ebComment)
            }
        )? {
        return c.branch(ifBlock, elseIfBlocks, elseBlock, ifComment)
    }

//   rule if
//     "if" _ condition _ "{" _ (branch_or_plugin _)* "}"
//     <LogStash::Config::AST::If>
//   end

// Moved _ after "{" into bops to simplify comment handling
// Moved _ after bop outside of bops to simplify comment handling

ifCond =
    "if" __ cond:condition __ "{" bops:(
            comment:_ bop:branchOrPlugin {
                return c.branchOrPluginComment(bop, comment)
            }
        )* footerComment:_ (
            "}" / &{
                return c.fatalError("expect closing curly bracket")
            }
        ) {
        return c.ifBlock(cond, bops, footerComment)
    }

//   rule else_if
//     "else" _ "if" _ condition _ "{" _ ( branch_or_plugin _)* "}"
//     <LogStash::Config::AST::Elsif>
//   end

// Moved _ after "{" into bops to simplify comment handling
// Moved _ after bop outside of bops to simplify comment handling

elseIf =
    "else" __ "if" __ cond:condition __ "{" bops:(
        comment:_ bop:branchOrPlugin {
            return c.branchOrPluginComment(bop, comment)
        }
    )* footerComment:_ (
        "}" / &{
            return c.fatalError("expect closing curly bracket")
        }
    ) {
        return c.elseIfBlock(cond, bops, footerComment)
    }

//   rule else
//     "else" _ "{" _ (branch_or_plugin _)* "}"
//     <LogStash::Config::AST::Else>
//   end

// Moved _ after "{" into bops to simplify comment handling
// Moved _ after bop outside of bops to simplify comment handling

elseCond =
    "else" __ "{" bops:(
        comment:_ bop:branchOrPlugin {
            return c.branchOrPluginComment(bop, comment)
        }
    )* footerComment:_ (
        "}" / &{
            return c.fatalError("expect closing curly bracket")
        }
    ) {
        return c.elseBlock(bops, footerComment)
    }

//   rule condition
//     expression (_ boolean_operator _ expression)*
//     <LogStash::Config::AST::Condition>
//   end

condition =
    cond:expression conds:(
        __ bo:booleanOperator __ cond:expression {
            return c.expression(bo, cond)
        }
    )* {
        return c.condition(cond, conds)
    }

//   rule expression
//     (
//         ("(" _ condition _ ")")
//       / negative_expression
//       / in_expression
//       / not_in_expression
//       / compare_expression
//       / regexp_expression
//       / rvalue
//     ) <LogStash::Config::AST::Expression>
//   end

expression =
    (
        (
            "(" __ cond:condition __ ")" {
                return c.conditionExpression(cond)
            }
        )
      / negativeExpression
      / inExpression
      / notInExpression
      / compareExpression
      / regexpExpression
      / rv:rvalue {
          return c.rvalue(rv)
      }
      // &{ return c.pushError("expect valid expression") }
    )

//   rule negative_expression
//     (
//         ("!" _ "(" _ condition _ ")")
//       / ("!" _ selector)
//     ) <LogStash::Config::AST::NegativeExpression>
//   end

negativeExpression =
    (
        (
            "!" __ "(" __ cond:condition __ (
                ")" / &{
                    return c.fatalError("expect closing parenthesis")
                }
            ) {
                return c.negativeExpression(cond)
            }
        )
      / (
          "!" __ sel:selector {
              return c.negativeSelector(sel)
          }
        )
    )

//   rule in_expression
//     rvalue _ in_operator _ rvalue
//     <LogStash::Config::AST::InExpression>
//   end

inExpression =
    lv:rvalue __ inOperator __ rv:rvalue {
        return c.inExpression(lv, rv)
    }

//   rule not_in_expression
//     rvalue _ not_in_operator _ rvalue
//     <LogStash::Config::AST::NotInExpression>
//   end

notInExpression =
    lv:rvalue __ notInOperator __ rv:rvalue {
        return c.notInExpression(lv, rv)
    }

//   rule in_operator
//     "in"
//   end

inOperator =
    "in" / &{
        return c.pushError("expect in operator (in)")
    }

//   rule not_in_operator
//     "not " _ "in"
//   end

notInOperator =
    "not " __ "in" / &{
        return c.pushError("expect not in operator (not in)")
    }

//   rule rvalue
//     string / number / selector / array / method_call / regexp
//   end

// Removed method_call due to https://github.com/elastic/logstash/issues/6698
// rvalue =
//     string_value / number / selector / array / method_call / regexp
rvalue =
    stringValue / number / selector / array / regexp / &{
        return c.pushError("invalid value for expression")
    }

//   rule method_call
//       method _ "(" _
//         (
//           rvalue ( _ "," _ rvalue )*
//         )?
//       _ ")"
//     <LogStash::Config::AST::MethodCall>
//   end

// Removed method_call due to https://github.com/elastic/logstash/issues/6698
// method_call  =
//       method _ "(" _
//         (
//           rvalue ( _ "," _ rvalue )*
//         )?
//       _ ")"

//   rule method
//     bareword
//   end

// Removed method_call due to https://github.com/elastic/logstash/issues/6698
// method =
//     bareword

//   rule compare_expression
//     rvalue _ compare_operator _ rvalue
//     <LogStash::Config::AST::ComparisonExpression>
//   end

compareExpression =
    lv:rvalue __ co:compareOperator __ rv:rvalue {
        return c.compareExpression(lv, co, rv)
    }

//   rule compare_operator
//     ("==" / "!=" / "<=" / ">=" / "<" / ">")
//     <LogStash::Config::AST::ComparisonOperator>
//   end

compareOperator =
    ("==" / "!=" / "<=" / ">=" / "<" / ">" / &{
        return c.pushError("expect compare operator (==, !=, <=, >=, <, >)")
    }) {
        return c.compareOperator()
    }

//   rule regexp_expression
//     rvalue _  regexp_operator _ (string / regexp)
//     <LogStash::Config::AST::RegexpExpression>
//   end

regexpExpression =
    lv:rvalue __  ro:regexpOperator __ rv:(stringValue / regexp) {
        return c.regexpExpression(lv, ro, rv)
    }

//   rule regexp_operator
//     ("=~" / "!~") <LogStash::Config::AST::RegExpOperator>
//   end

regexpOperator =
    ("=~" / "!~" / &{
        return c.pushError("expect regexp comparison operator (=~, !~)")
    }) {
        return c.regexpOperator()
    }

//   rule boolean_operator
//     ("and" / "or" / "xor" / "nand")
//     <LogStash::Config::AST::BooleanOperator>
//   end

booleanOperator =
    ("and" / "or" / "xor" / "nand" / &{
        return c.pushError("expect boolean operator (and, or, xor, nand)")
    }) {
        return c.booleanOperator()
    }

//   rule selector
//     selector_element+
//     <LogStash::Config::AST::Selector>
//   end

selector =
    ses:selectorElement+ {
        return c.selector(ses)
    }

//   rule selector_element
//     "[" [^\]\[,]+ "]"
//     <LogStash::Config::AST::SelectorElement>
//   end

selectorElement =
    "[" [^\][,]+ (
        "]" / &{
            return c.pushError("expect closing square bracket")
        }
    ) {
        return c.selectorElement()
    }

EOF = !.