Pegjs: 생성된 파서의 일관되지 않은 동작

좋습니다. 정확하게 채웠습니다 👍 이제 문법만 있으면 도와드릴 수 있습니다 😄

여기 있습니다:

// GRAMMAR
const parser = peg.generate(`
{
  function getFlattenedValue (value) {
    if (!value) return undefined
    return Array.isArray(value)
      ? value.map(function(v){return v.value})
      : value.value
  }
  function getValueType (value) {
    if (!value) return undefined
    var rawType = value.type
    if (Array.isArray(value))
      rawType = value[0].type
    switch (rawType) {
      case 'string':
      case 'number':
      case 'boolean':
        return rawType
      default:
        return 'string'
    }
  }
  function getAttributeType (target, op, val) {
    if (typeof target === 'string' && target.indexOf('attributes.') === 0) {
      if (!val)
        return undefined
      switch (op) {
        case 'in':
        case 'not in':
          return val[0].type;
        case 'contains':
          return 'set-' + val.type
        default:
          return Array.isArray(val) ? 'set-' + val[0].type : val.type;
      }
    }
  }
  function transformToCondition (target, op, val) {
    return {
      kind: "condition",
      target: target,
      operator: op,
      value: getFlattenedValue(val),
      valueType: getValueType(val),
      attributeType: getAttributeType(target, op, val),
    }
  }

  function createIdentifier (body) {
    return body
      .map(identifiers => identifiers.filter(identifier => (identifier && identifier !== '.'))) // gets raw_identifiers without dots and empty identifiers
      .filter(identifiers => identifiers.length > 0) // filter out empty identifiers arrays
      .map(identifiers => identifiers.join('.'))
      .join('.') // join back to construct the path
  }
}

// ----- DSL Grammar -----
predicate
  = ws exp:expression ws { return exp; }

expression
  = head:term tail:("or" term)*
    {
      if (tail.length === 0) {
        return head;
      }

      return {
        kind: "logical",
        logical: "or",
        conditions: [head].concat(tail.map(function(el){return el[1];})),
      };
    }

term
  = head:factor tail:("and" factor)*
    {
      if (tail.length === 0) {
        return head;
      }

      return {
        kind: "logical",
        logical: "and",
        conditions: [head].concat(tail.map(function(el){return el[1];})),
      };
    }

factor
  = ws negation:"not" ws primary:primary ws
    {
      return {
        kind: "negation",
        condition: primary,
      };
    }
  / ws primary:primary ws { return primary; }

primary
  = basic_comparison
  / list_comparison
  / empty_comparison
  / parens

// ----- Comparators -----
basic_comparison
  = target:val_expression ws op:single_operators ws val:value
    { return transformToCondition(target, op, val); }

list_comparison
  = target:val_expression ws op:list_operators ws val:list_of_values
    { return transformToCondition(target, op, val); }

empty_comparison
  = target:val_expression ws op:empty_operators
    { return transformToCondition(target, op); }

// ----- Operators -----
single_operators
  = "!="
  / "="
  / "<>"
  / ">="
  / ">"
  / "<="
  / "<"
  / "contains"

list_operators
  = "!="
  / "="
  / "<>"
  / "not in"
  / "in"
  / "contains all"
  / "contains any"

empty_operators
  = "is not empty"
  / "is empty"
  / "is not defined"
  / "is defined"

list_of_values
  = ws "(" ws head:value tail:(ws "," ws value)* ws ")" ws
    {
      if (tail.length === 0) {
        return [head];
      }
      return [head].concat(tail.map(function(el){ return el[el.length -1];}));
    }

// ----- Expressions -----
val_expression
  = application_expression
  / constant_expression
  / field_expression

application_expression
  = identifier ws "(" ws function_argument (ws "," ws function_argument)* ws ")"
constant_expression = ws val:value ws { return val; }
field_expression = ws i:identifier ws { return i; }

function_argument
  = expression
  / constant_expression
  / field_expression

value
  = v:boolean { return { type: 'boolean', value: v }; }
  / v:datetime { return { type: 'datetime', value: v }; }
  / v:date { return { type: 'date', value: v }; }
  / v:time { return { type: 'time', value: v }; }
  / v:number { return { type: 'number', value: v }; }
  / v:string { return { type: 'string', value: v }; }

// ----- Common rules -----
parens
  = ws "(" ws ex:expression ws ")" ws { return ex; }

identifier
  = body:((raw_identifier "." escaped_identifier)+ / (raw_identifier "." raw_identifier)+)
    { 
      return createIdentifier(body)
    }
    / i:raw_identifier { return i; }

escaped_identifier
  = "\`" head:raw_identifier tail:("-" raw_identifier)* "\`"
    { return [head].concat(tail.map(function(el){return el.join('');})).join(''); }

raw_identifier = i:[a-zA-Z0-9_]* { return i.join(''); }

ws "whitespace" = [ \\t\\n\\r]*

// ----- Types: booleans -----
boolean "boolean"
  = "false" { return false; }
  / "true" { return true; }

// ----- Types: datetime -----
datetime "datetime"
  =  quotation_mark datetime:datetime_format quotation_mark
    { return datetime.map(function(el){return Array.isArray(el) ? el.join('') : el;}).join(''); }

datetime_format = date_format time_mark time_format zulu_mark
time_mark = "T"
zulu_mark = "Z"

// ----- Types: date -----
date "date"
  =  quotation_mark date:date_format quotation_mark { return date.join("");}

date_format = [0-9][0-9][0-9][0-9] minus [0-9][0-9] minus [0-9][0-9]

// ----- Types: time -----
time "time"
  =  quotation_mark time:time_format quotation_mark { return time.join("");}

time_format = [0-2][0-9] colon [0-5][0-9] colon [0-5][0-9] decimal_point [0-9][0-9][0-9]
colon = ":"

// ----- Types: numbers -----
number "number"
  = minus? int frac? exp? { return parseFloat(text()); }

decimal_point = "."
digit1_9 = [1-9]
e = [eE]
exp = e (minus / plus)? DIGIT+
frac = decimal_point DIGIT+
int = zero / (digit1_9 DIGIT*)
minus = "-"
plus = "+"
zero = "0"

// ----- Types: strings -----
string "string"
  = quotation_mark chars:char* quotation_mark { return chars.join(""); }

char
  = unescaped
  / escape
    sequence:(
        '"'
      / "\\\\"
      / "/"
      / "b" { return "\\b"; }
      / "f" { return "\\f"; }
      / "n" { return "\\n"; }
      / "r" { return "\\r"; }
      / "t" { return "\\t"; }
      / "u" digits:$(HEXDIG HEXDIG HEXDIG HEXDIG)
        { return String.fromCharCode(parseInt(digits, 16)); }
    )
    { return sequence; }

escape = "\\\\"
quotation_mark = '"'
unescaped = [^\\0-\\x1F\\x22\\x5C]
// See RFC 4234, Appendix B (http://tools.ietf.org/html/rfc4234).
DIGIT  = [0-9]
HEXDIG = [0-9a-f]i

버그에 약간의 관련 추가. pegjs-loader 를 통해 pegjs 를 설정했습니다. parser.generate 호출하는 후드 아래 JS API에서 작동하며 동일한 오류가 발생합니다.

그건 그렇고 프로젝트에 대해 많은 감사드립니다!

@emmenko 귀하의 문법이 API와 함께 작동하는 이유를 모르겠습니다(이유를 계속 찾으려고 노력할 것입니다). 하지만 귀하의 문법이 올바르지 않은 경우 unescaped 규칙은 다음과 같아야 합니다.

unescaped = !'"' [^\\0-\\x1F\\x22\\x5C]

이렇게 하면 문제가 해결되는지 알려주십시오.

@tdeekens 동일한 오류(예: Expected ... but "\"" found. )인 경우 문법이 올바른지 확인하거나 여기에 게시하십시오.

@futagoza 저와 @tdeekens 는 같은 팀이라 같은 문제입니다 😅

계속 알려드리겠습니다! 지금까지 응원해주셔서 감사합니다🙏

귀하의 문법이 API와 함께 작동하는 이유를 모르겠습니다.

우리는 솔직히 그것에 대해 문제가 없었습니다. 그래도 지적해주셔서 감사합니다!

지금 작동합니까?

불행히도 도움이되지 않았습니다 ☹️

문법, PEG.js 0.10, Node 8.9.0 및 foo = "bar" 입력을 사용하여 3가지 경로를 통해 이것을 시도했습니다.

1. https://pegjs.org/online
2. PEG.js API
3. pegjs CLI

3개 모두 동일한 오류를 표시했습니다: Line 1, column 7: Expected "(", boolean, date, datetime, number, string, or time but "\"" found.

문법을 변경하면 3가지 경로 모두에 대해 이 오류가 수정됩니다.

// orignal
unescaped = [^\\0-\\x1F\\x22\\x5C]

// fixed
unescaped = !'"' [^\\0-\\x1F\\x22\\x5C]

고정 규칙을 적용한 후 다음 사항을 확인할 수 있습니다.

• 동일한 오류 메시지 또는 다른 오류가 표시됩니다.
• 내가 언급한 것과 다른(또는 추가 단계)를 수행하고 있습니다.
• PEG.js API를 사용할 때 옵션을 사용 중입니까?

또한 입력을 약간 조정한 후 문법이 줄 바꿈을 공백으로 올바르게 설명하지 않는다는 것을 깨달았습니다. 이는 ws 규칙 때문일 가능성이 큽니다.

편집: 내 테스트 스크립트는 다음과 같습니다.

/* eslint node/no-unsupported-features: 0 */

"use strict";

const { exec } = require( "child_process" );
const { readFileSync } = require( "fs" );
const { join } = require( "path" );
const { generate } = require( "pegjs" );

function test( parser ) {

    try {

        console.log( parser.parse( `foo = "bar"` ) );

    } catch ( error ) {

        if ( error.name !== "SyntaxError" ) throw error;

        const loc = error.location.start;

        console.log( `Line ${ loc.line }, column ${ loc.column }: ${ error.message }` );

    }

}

const COMMAND = process.argv[ 2 ];
switch ( COMMAND ) {

    case "api":
        test( generate( readFileSync( join( __dirname, "grammar.pegjs" ), "utf8" ) ) );
        break;

    case "cli":
        exec( "node node_modules/pegjs/bin/pegjs -o parser.js grammar.pegjs", error => {

            if ( error ) console.error( error ), process.exit( 1 );

            test( require( "./parser" ) );

        } );
        break;

    default:
        console.error( `Invalid command "${ COMMAND }" passed to test script.` );
        process.exit( 1 );

}

피드백 주셔서 감사합니다! 귀하의 제안으로 내일 시도하고 도움이 되었다면 최대한 빨리 알려 드리겠습니다. 🙏

피드백을 주셔서 감사합니다. 혼란을 드려 먼저 사과드립니다. 나는 문제가 webpack-loader에도 있다는 것을 지적하고 싶었습니다. 이 문제로 혼란을 드려 죄송합니다.

우리는 개선을 시도했습니다. 일반적으로 파서를 수정하지만 새로운 문제가 발생하여 그 이유를 이해하는 데 어려움을 겪습니다.

테스트의 예는 다음과 같습니다(자세한 내용은 아래 참조).

Object {
+   "attributeType": undefined,
    "kind": "condition",
    "operator": "=",
    "target": "foo",
-   "value": "bar",
+   "value": ",b,a,r",
    "valueType": "string",
}

우리는 오류가 우리 편일 가능성이 있다고 생각합니다. 아직 어디 있는지 확실하지 않습니다. 이것은 예를 들어 다음 입력에서 발생합니다.

categories.id != ("b33f8e3a-f8d1-476f-a595-2615c4b57556")

되는

categories.id != (",b,3,3,f,8,e,3,a,-,f,8,d,1,-,4,7,6,f,-,a,5,9,5,-,2,6,1,5,c,4,b,5,7,5,5,6")

구문 분석할 때.

우리는 분명히 단서에 대해 매우 감사할 것이지만 거기에서 우리를 지원할 수 있는지 이해합니다.

이런, 내 실수 😨, 이것은 그것을 고칠 것입니다

unescaped = !'"' value:[^\\0-\\x1F\\x22\\x5C] { return value; }

매우 빠른 응답에 감사드립니다. SyntaxError: Expected "(", boolean, date, datetime, number, string, or time but "\"" found. 의 초기 오류를 자주 반환하는 CLI 또는 webpack-loader를 사용할 때는 도움이 되지만 도움이 되지 않습니다. 예를 들어 not(sku = "123") 또는 더 복잡한 예제 lineItemTotal(sku = "SKU1" or list contains all (1,2,3), field.name, "third arg") = "10 EUR" 입니다. 탈출과 여전히 관련이 있습니까?

네, 이중 탈출 때문인 것으로 밝혀졌습니다. 다음은 고정 규칙입니다.

ws "whitespace" = [ \t\n\r]*

char
  = unescaped
  / escape
    sequence:(
        '"'
      / "\\"
      / "/"
      / "b" { return "\b"; }
      / "f" { return "\f"; }
      / "n" { return "\n"; }
      / "r" { return "\r"; }
      / "t" { return "\t"; }
      / "u" digits:$(HEXDIG HEXDIG HEXDIG HEXDIG)
        { return String.fromCharCode(parseInt(digits, 16)); }
    )
    { return sequence; }

escape = "\\"

unescaped = !'"' value:[^\0-\x1F\x22\x5C] { return value; }

편집: 복잡한 예제를 구문 분석하는 규칙에 대해 작업하려는 것 같습니다. lineItemTotal(sku = "SKU1" or list contains all (1,2,3), field.name, "third arg") = "10 EUR" , 현재 이상한 "kind":"condition" 노드를 출력하고 있습니다.

많은 도움과 조언 부탁드립니다. 우리가 가진 문제를 해결하는 것 같습니다. "조건" 노드에 대한 조언을 살펴보겠습니다.

반갑습니다 😄