Version 1.4.3: Infrastructure improvements.

Feature new

• Script files: all script files are now for both Unix and Windows available.

Features modified

• Test Data Generator:
  -- the scripts and the program code have been moved to the test directory,
  -- the scope of test data generation can now be determined using environment variables.

Version 1.4.2: Enhancement of the test data.

Feature new

• Adding examples from The Neo4j Developer Manual v3.3 to the test data.

Features modified

• Cleaning up the lex definitions.
• Support of the grammar rule ParenthesizedExpression.

Version 1.4.1: Minor refinements.

Feature new

• Support of geas in the rebar3 test profile.

Features modified

• Adding a reasoning documentation for the generation sequence in the test data generator to the program code.
• Improving the performance of the test data generation by an increasing of the heap size.

Version 1.4.0: Update to latest grammar definitions.

Feature new

• Support of BNFC.

Features modified

• Improving list performance.
• Running a script files creates a logging file.
• Support of dialyzer.

Feature removed

• Support of Amber.

Version 1.3.1: Update to latest grammar definitions.

Merge pull request #73 from walter-weinmann/wwe

Version 1.3.1.

Version 1.3.0: Update to latest grammar definitions.

Features modified

• Refactoring of the test data generator (ocparse_generator) in order to modularize.
• Refactoring of the test driver (ocparse_test.erl) to facilitate the error analysis.

Features omitted

• Legacy version support is discontinued.

Version 1.2.6: Minor configuration refinements.

Merge pull request #66 from walter-weinmann/wwe

Minor configuration refinements.

Version 1.2.5: Conflicting module name.

Renaming test_generatorto ocparse_generator.

Version 1.2.4: OpenCypher 1.0.0-M04.

Release Date: 31.12.2016 - Grammar as of 20.12.2016

Grammar changes

• Atom

New: Atom = Literal
          | Parameter
          | ((C,O,U,N,T), [SP], '(', [SP], '*', [SP], ')')
          | ListComprehension
          | ((F,I,L,T,E,R), [SP], '(', [SP], FilterExpression, [SP], ')')
          ...

Old: Atom = NumberLiteral
          | StringLiteral
          | Parameter
          | (T,R,U,E)
          | (F,A,L,S,E)
          | (N,U,L,L)
          | ((C,O,U,N,T), [SP], '(', [SP], '*', [SP], ')')
          | MapLiteral
          | ListComprehension
          | ('[', [SP], Expression, [SP], { ',', [SP], Expression, [SP] }, ']')
          | ((F,I,L,T,E,R), [SP], '(', [SP], FilterExpression, [SP], ')')
          ...     

• BooleanLiteral

New: BooleanLiteral = (T,R,U,E)
                    | (F,A,L,S,E)
                    ;

Old: n/a

• DecimalInteger

New: DecimalInteger = ZeroDigit
                    | (NonZeroDigit, { Digit })
                    ;

Old: DecimalInteger = (('1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'), [DigitString])
                    | '0'
                    ;

• Delete

New: Delete = [(D,E,T,A,C,H), SP], (D,E,L,E,T,E), [SP], Expression, { [SP], ',', [SP], Expression } ;

Old: Delete = ((D,E,L,E,T,E), Expression, { ',', Expression })
            | ((D,E,T,A,C,H), SP, (D,E,L,E,T,E), Expression, { ',', Expression })
            ;

• Digit

New: Digit = ZeroDigit
           | NonZeroDigit
           ;

Old: Digit = '0'
           | '1'
           | '2'
           | '3'
           | '4'
           | '5'
           | '6'
           | '7'
           | '8'
           | '9'
           ;

• DigitString

New: n/a

Old: DigitString = { Digit }- ;

• ExponentDecimalReal

New: ExponentDecimalReal = ({ Digit }- | ({ Digit }-, '.', { Digit }-) | ('.', { Digit }-)), ((E) | (E)), ['-'], { Digit }- ;

Old: ExponentDecimalReal = ({ Digit | '.' }- | DecimalInteger), ((E) | (E)), (DigitString | DecimalInteger) ;

• HexDigit

New: HexDigit = Digit
              | HexLetter
              ;

Old: HexDigit = '0'
              | '1'
              | '2'
              | '3'
              | '4'
              | '5'
              | '6'
              | '7'
              | '8'
              | '9'
              | (A)
              | (B)
              | (C)
              | (D)
              | (E)
              | (F)
              ;

• HexInteger

New: HexInteger = ('0',X), { HexDigit }- ;

Old: HexInteger = ('0',X), HexString ;

• HexLetter

New: HexLetter = (A)
               | (B)
               | (C)
               | (D)
               | (E)
               | (F)
               ;

Old: n/a

• HexString

New: n/a

Old: HexString = { HexDigit }- ;

• ListComprehension

New: ListComprehension = '[', [SP], FilterExpression, [[SP], '|', [SP], Expression], [SP], ']' ;

Old: ListComprehension = '[', FilterExpression, [[SP], '|', Expression], ']' ;

• ListLiteral

New: ListLiteral = '[', [SP], [Expression, [SP], { ',', [SP], Expression, [SP] }], ']' ;

Old: n/a

• Literal

New: Literal = NumberLiteral
             | StringLiteral
             | BooleanLiteral
             | (N,U,L,L)
             | MapLiteral
             | ListLiteral
             ;

Old: n/a

• NonZeroDigit

New: NonZeroDigit = NonZeroOctDigit
                  | '8'
                  | '9'
                  ;

Old: n/a

• NonZeroOctDigit

New: NonZeroOctDigit = '1'
                     | '2'
                     | '3'
                     | '4'
                     | '5'
                     | '6'
                     | '7'
                     ;

Old: n/a

• OctalInteger

New: OctalInteger = ZeroDigit, { OctDigit }- ;

Old: OctalInteger = '0', OctalString ;

• OctalString

New: n/a

Old: OctalString = { OctDigit }- ;

• OctDigit

New: OctDigit = ZeroDigit
              | NonZeroOctDigit
              ;

Old: OctDigit = '0'
              | '1'
              | '2'
              | '3'
              | '4'
              | '5'
              | '6'
              | '7'
              ;

• RegularDecimalReal

New: RegularDecimalReal = { Digit }, '.', { Digit }- ;

Old: RegularDecimalReal = ({ Digit } | DecimalInteger), '.', (DigitString | DecimalInteger) ;

• Return

New: Return = (R,E,T,U,R,N), [[SP], (D,I,S,T,I,N,C,T)], SP, ReturnBody ;

Old: Return = ((R,E,T,U,R,N), SP, (D,I,S,T,I,N,C,T), SP, ReturnBody)
            | ((R,E,T,U,R,N), SP, ReturnBody)
            ;

• VersionNumber (Legacy)

New: VersionNumber = RegularDecimalReal ;

Old: VersionNumber = DecimalInteger, '.', DecimalInteger ;

• With

New: With = (W,I,T,H), [[SP], (D,I,S,T,I,N,C,T)], SP, ReturnBody, [[SP], Where] ;


Old: With = ((W,I,T,H), (D,I,S,T,I,N,C,T), SP, ReturnBody, [Where])
          | ((W,I,T,H), SP, ReturnBody, [Where])
          ;

• ZeroDigit

New: ZeroDigit = '0' ;


Old: n/a

Version 1.2.3: Minor grammar changes.

Release Date: 15.12.2016 - Grammar as of 14.12.2016

Grammar changes

• Expression9

New: Expression9 = { (N,O,T), [SP] }, Expression8 ;

Old: Expression9 = { SP, (N,O,T), SP }, Expression8 ;

• LiteralIds (Legacy)

New: LiteralIds = IntegerLiteral, { [SP], ',', [SP], IntegerLiteral } ;

Old: LiteralIds = { [SP], ',', [SP] } ;

• NodeLookup (Legacy)

New: NodeLookup = (N,O,D,E), [SP], (IdentifiedIndexLookup | IndexQuery | IdLookup) ;

Old: NodeLookup = (N,O,D,E), (IdentifiedIndexLookup | IndexQuery | IdLookup) ;

• PeriodicCommitHint (Legacy)

New: PeriodicCommitHint = (U,S,I,N,G), SP, (P,E,R,I,O,D,I,C), SP, (C,O,M,M,I,T), [SP, IntegerLiteral] ;

Old: PeriodicCommitHint = (U,S,I,N,G), SP, (P,E,R,I,O,D,I,C), SP, (C,O,M,M,I,T), [SP] ;

• SortItem

New: SortItem = Expression, [[SP], ((A,S,C,E,N,D,I,N,G) | (A,S,C) | (D,E,S,C,E,N,D,I,N,G) | (D,E,S,C))] ;

Old: SortItem = (Expression, ((D,E,S,C,E,N,D,I,N,G) | (D,E,S,C)))
              | (Expression, [(A,S,C,E,N,D,I,N,G) | (A,S,C)])
              ;