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 कॉलिंग हुड के तहत संचालित होता है, यह भी उसी त्रुटि की ओर जाता है।

वैसे परियोजना के लिए बहुत धन्यवाद!

@emmenko मुझे नहीं पता कि आपका व्याकरण एपीआई के साथ क्यों काम कर रहा था (क्यों पता लगाने की कोशिश करना जारी रखेगा), लेकिन आपका व्याकरण गलत था, unescaped नियम होना चाहिए:

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

मुझे बताएं कि क्या यह आपकी तरफ से समस्या को ठीक करता है

@tdeekens यदि यह वही त्रुटि है (जैसे Expected ... but "\"" found. ), तो जांचें कि क्या आपका व्याकरण सही है, या इसे यहां पोस्ट करें

@futagoza me और @tdeekens एक ही टीम में हैं, इसलिए यह वही मुद्दा है

हम आपको तैनात रखेंगे! अब तक आपके समर्थन के लिए धन्यवाद 🙏

मुझे नहीं पता कि आपका व्याकरण एपीआई के साथ क्यों काम कर रहा था

ईमानदार होने के लिए हमें इससे कभी कोई समस्या नहीं थी। वैसे भी इसे इंगित करने के लिए धन्यवाद!

क्या अब यह काम कर रहा है?

दुर्भाग्य से इसने मदद नहीं की ️

आपके व्याकरण, PEG.js 0.10, Node 8.9.0 और इनपुट foo = "bar" , मैंने इसे 3 मार्गों के माध्यम से आजमाया:

1. https://pegjs.org/online
2. खूंटी.जेएस एपीआई
3. pegjs सीएलआई

सभी 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 );

}

प्रतिक्रिया के लिए बहुत धन्यवाद! हम कल आपके सुझाव के साथ प्रयास करेंगे और अगर इससे मदद मिली तो हम आपको जल्द से जल्द बताएंगे। 🙏

फीडबैक देने के लिए धन्यवाद। पहले भ्रम के लिए खेद है। मैं सिर्फ यह बताना चाहता था कि समस्या वेबपैक-लोडर में भी थी। खेद है कि इस मुद्दे पर भ्रम पैदा हुआ।

हमने सुधार की कोशिश की। यह सामान्य रूप से पार्सर को ठीक करता है लेकिन हम एक नए मुद्दे में भाग लेते हैं, अब हमें इसका कारण समझने में मुश्किल होती है।

एक उदाहरण एक परीक्षण का है (अधिक नीचे)

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. की प्रारंभिक त्रुटि लौटाता है। कुछ ऐसा जो उदाहरण के लिए 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" नोड का उत्पादन कर रहा है

मदद और सलाह के लिए बहुत-बहुत धन्यवाद। ऐसा लगता है कि हमारी समस्याओं का समाधान हो गया है। हम "हालत" नोड के संबंध में सलाह देखेंगे।

आपका स्वागत है