Implement parser.

Author: jameswilddev

src/Parsing/Parser.php

@@ -0,0 +1,349 @@
+<?php
+
+namespace JamesWildDev\DBMLParser\Parsing;
+
+/**
+ * Values which identify the states of parsers.
+ */
+class ParserState
+{
+  /**
+   * No tokens are currently being aggregated.
+   */
+  const BETWEEN_STATEMENTS = 0;
+
+  /**
+   * The keyword "table" has been stated but nothing more.
+   */
+  const TABLE = 1;
+
+  /**
+   * The keyword "table" and the following name have been given.
+   */
+  const TABLE_NAMED = 2;
+
+  /**
+   * The alias of a table is next ("table {name} as").
+   */
+  const TABLE_AS = 3;
+
+  /**
+   * The next token should be the opening brace of a table.
+   */
+  const TABLE_ALIASED = 4;
+
+  /**
+   * Inside a table, but not parsing any particular thing yet.
+   */
+  const TABLE_BODY = 5;
+
+  /**
+   * A column has been named.
+   */
+  const COLUMN_NAMED = 6;
+
+  /**
+   * A column has been named and given a type.
+   */
+  const COLUMN_TYPED = 7;
+
+  /**
+   * The size of a column is expected next (following "(", the opening parenthesis of a column size).
+   */
+  const COLUMN_BEFORE_SIZE = 8;
+
+  /**
+   * The size of a column has been given and the closing parenthesis (")") is expected next.
+   */
+  const COLUMN_SIZED = 9;
+
+  /**
+   * The closing parenthesis (")") has been given following a column's size.
+   */
+  const COLUMN_AFTER_SIZE = 10;
+
+  /**
+   * Either a closing bracket ("]") or the start of a column attribute ("pk", "not null", etc.) is expected.
+   */
+  const COLUMN_AFTER_COMMA = 11;
+
+  /**
+   * The "default" attribute has been added to a column.  Next is a semicolon.
+   */
+  const COLUMN_DEFAULT = 12;
+
+  /**
+   * The "default" attribute has been added to a column, and has been followed by a semicolon.  Next is a string literal describing the default.
+   */
+  const COLUMN_DEFAULT_SEMICOLON = 13;
+
+  /**
+   * The "pk" attribute has been added to a column.  Next is a closing bracket ("]") or a comma (",").
+   */
+  const COLUMN_AFTER_PRIMARY_KEY = 14;
+
+  /**
+   * The "increment" attribute has been added to a column.  Next is a closing bracket ("]") or a comma (",").
+   */
+  const COLUMN_AFTER_INCREMENT = 15;
+
+  /**
+   * A constant "default" attribute has been added to a column.  Next is a closing bracket ("]") or a comma (",").
+   */
+  const COLUMN_AFTER_CONSTANT_DEFAULT = 16;
+
+  /**
+   * A calculated "default" attribute has been added to a column.  Next is a closing bracket ("]") or a comma (",").
+   */
+  const COLUMN_AFTER_CALCULATED_DEFAULT = 17;
+
+  /**
+   * The word "not" has been added to a column.  Next is "null".
+   */
+  const COLUMN_NOT = 18;
+
+  /**
+   * A "not null" attribute has been added to a column.  Next is a closing bracket ("]") or a comma (",").
+   */
+  const COLUMN_AFTER_NOT_NULL = 19;
+
+  /**
+   * The word "note" has been added to a column.  Next is a semicolon.
+   */
+  const COLUMN_NOTE = 20;
+
+  /**
+   * The word "note" and a semicolon have been added to a column.  Next is a string literal.
+   */
+  const COLUMN_NOTE_SEMICOLON = 21;
+
+  /**
+   * The word "note", a semicolon and a string literal have been added to a column.  Next is a closing bracket ("]") or a comma (",").
+   */
+  const COLUMN_AFTER_NOTE = 22;
+
+  /**
+   * The word "ref" has been added to a column.  Next is a semicolon.
+   */
+  const COLUMN_REF = 23;
+
+  /**
+   * The word "ref" and a semicolon have been added to a column.  Next is an operator.
+   */
+  const COLUMN_REF_SEMICOLON = 24;
+
+  /**
+   * The word "ref", a semicolon and an operator have been added to a column.  Next is a referenced table name.
+   */
+  const COLUMN_REF_OPERATOR = 25;
+
+  /**
+   * The word "ref", a semicolon, an operator and a referenced table name or alias have been added to a column.  Next is a period between the referenced table and column names.
+   */
+  const COLUMN_REF_REFERENCED_TABLE_NAME_OR_ALIAS = 26;
+
+  /**
+   * The word "ref", a semicolon, an operator, a referenced table name or alias and a period have been added to a column.  Next is a referenced column name.
+   */
+  const COLUMN_REF_PERIOD = 27;
+
+  /**
+   * The word "ref", a semicolon, an operator, a referenced table name or alias, a period and a referenced column name have been added to a column.  Next is a closing bracket ("]") or a comma (",").
+   */
+  const COLUMN_AFTER_REF = 28;
+
+  /**
+   * The word "indexes" has been given in a table body.  Next is an opening brace ("{").
+   */
+  const INDEXES = 29;
+
+  /**
+   * Inside an index block, but not parsing any particular index yet.
+   */
+  const INDEXES_BODY = 30;
+
+  /**
+   * The columns of an index have been given.  Next is a closing brace ("}"), opening bracket ("["), identifier of another column to index, or an opening parenthesis (of a list of columns).
+   */
+  const INDEX_COLUMNS = 31;
+
+  /**
+   * An opening parenthesis ("(") for a multiple-column index has been given.  Next is an identifier of the first column.
+   */
+  const INDEX_OPENING_PARENTHESIS = 32;
+
+  /**
+   * A name of a column to index has been given.  Next is a comma (",") or a closing parenthesis (")").
+   */
+  const INDEX_MULTIPLE_NAME = 33;
+
+  /**
+   * Between attributes of an index.
+   */
+  const INDEX_AFTER_COMMA = 34;
+
+  /**
+   * The "unique" attribute has been added to an index.  Next is a comma (",") or a closing bracket ("]").
+   */
+  const INDEX_AFTER_UNIQUE = 35;
+
+  /**
+   * The word "name" has been added to an index.  Next is a semicolon (":").
+   */
+  const INDEX_NAME = 36;
+
+  /**
+   * The word "name" and a semicolon (":") have been added to an index.  Next is a name (a string literal).
+   */
+  const INDEX_NAME_SEMICOLON = 37;
+
+  /**
+   * A "name" attribute has been added to an index.  Next is a comma (",") or a closing bracket ("]").
+   */
+  const INDEX_AFTER_NAME = 38;
+
+  /**
+   * The "unique" attribute has been added to a column.  Next is a closing bracket ("]") or a comma (",").
+   */
+  const COLUMN_AFTER_UNIQUE = 39;
+
+  /**
+   * The word "note" has been added to a table.  Next is a semicolon (":") or an opening brace ("{").
+   */
+  const TABLE_NOTE = 40;
+
+  /**
+   * The word "note" and a semicolon have been added to a table.  Next is a string literal.
+   */
+  const TABLE_NOTE_SEMICOLON = 41;
+
+  /**
+   * The word "ref" has been added.  Next is a semicolon.
+   */
+  const REF = 42;
+
+  /**
+   * The word "ref" and a semicolon have been added.  Next is a referencing table name.
+   */
+  const REF_SEMICOLON = 43;
+
+  /**
+   * The word "ref", a semicolon, an operator and a referencing table name or alias have been added.  Next is a period between the referencing table and column names.
+   */
+  const REF_REFERENCING_TABLE_NAME_OR_ALIAS = 44;
+
+  /**
+   * The word "ref", a semicolon, a referencing table name or alias and a period have been added.  Next is a referencing column name.
+   */
+  const REF_REFERENCING_PERIOD = 45;
+
+  /**
+   * The word "ref", a semicolon, a referencing table name or alias, a period and a referencing column name have been added.  Next is an operator.
+   */
+  const REF_REFERENCING_COLUMN_NAME = 46;
+
+  /**
+   * The word "ref", a semicolon, a referencing table name or alias, a period, a referencing column name and an operator have been added.  Next is a referenced table name.
+   */
+  const REF_OPERATOR = 47;
+
+  /**
+   * The word "ref", a semicolon, a referencing table name or alias, a period, a referencing column name, an operator and a referenced table name have been added.  Next is a period between the referenced table and column names.
+   */
+  const REF_REFERENCED_TABLE_NAME_OR_ALIAS = 48;
+
+  /**
+   * The word "ref", a semicolon, a referencing table name or alias, a period, a referencing column name, an operator, a referenced table name and a period have been added.  Next is a referenced column name.
+   */
+  const REF_REFERENCED_PERIOD = 49;
+
+  /**
+   * The word "enum" has been added.  Next is the name of the enum.
+   */
+  const ENUM = 50;
+
+  /**
+   * The word "enum" and the following name have been given.  Next is the opening brace. ("{").
+   */
+  const ENUM_NAME = 51;
+
+  /**
+   * Inside an enum, but not parsing any particular thing yet.
+   */
+  const ENUM_BODY = 52;
+
+  /**
+   * The name of an enum value has been given.
+   */
+  const ENUM_VALUE_NAME = 53;
+
+  /**
+   * The name of an enum value and an opening bracket have been given.  Next is the word "note" or a closing bracket ("]").
+   */
+  const ENUM_VALUE_OPENING_BRACKET = 54;
+
+  /**
+   * The name of an enum value, an opening bracket and the word "note" have been given.  Next is a semicolon (":").
+   */
+  const ENUM_VALUE_NOTE = 55;
+
+  /**
+   * The name of an enum value, an opening bracket, the word "note" and a semicolon have been given.  Next is the content of the note.
+   */
+  const ENUM_VALUE_NOTE_SEMICOLON = 56;
+
+  /**
+   * The name of an enum value, an opening bracket, the word "note", a semicolon and the content of the note have been given.  Next is the closing bracket ("]").
+   */
+  const ENUM_VALUE_NOTE_CONTENT = 57;
+
+  /**
+   * The word "note" and an opening brace have been added to a table.  Next is a string literal.
+   */
+  const TABLE_NOTE_OPENING_BRACE = 58;
+
+  /**
+   * The word "note", an opening brace and a string literal have been added to a table.  Next is a closing brace ("}").
+   */
+  const TABLE_NOTE_BRACED_CONTENT = 59;
+
+  /**
+   * The word "ref" and an opening brace have been added.  Next is a referencing table name.
+   */
+  const BRACED_REF = 60;
+
+  /**
+   * The word "ref", an opening brace, an operator and a referencing table name or alias have been added.  Next is a period between the referencing table and column names.
+   */
+  const BRACED_REF_REFERENCING_TABLE_NAME_OR_ALIAS = 61;
+
+  /**
+   * The word "ref", an opening brace, a referencing table name or alias and a period have been added.  Next is a referencing column name.
+   */
+  const BRACED_REF_REFERENCING_PERIOD = 62;
+
+  /**
+   * The word "ref", an opening brace, a referencing table name or alias, a period and a referencing column name have been added.  Next is an operator.
+   */
+  const BRACED_REF_REFERENCING_COLUMN_NAME = 63;
+
+  /**
+   * The word "ref", an opening brace, a referencing table name or alias, a period, a referencing column name and an operator have been added.  Next is a referenced table name.
+   */
+  const BRACED_REF_OPERATOR = 64;
+
+  /**
+   * The word "ref", an opening brace, a referencing table name or alias, a period, a referencing column name, an operator and a referenced table name have been added.  Next is a period between the referenced table and column names.
+   */
+  const BRACED_REF_REFERENCED_TABLE_NAME_OR_ALIAS = 65;
+
+  /**
+   * The word "ref", an opening brace, a referencing table name or alias, a period, a referencing column name, an operator, a referenced table name and a period have been added.  Next is a referenced column name.
+   */
+  const BRACED_REF_REFERENCED_PERIOD = 66;
+
+  /**
+   * The word "ref", an opening brace, a referencing table name or alias, a period, a referencing column name, an operator, a referenced table name, a period and a referenced column name have been added.  Next is a closing brace ("}").
+   */
+  const BRACED_REF_REFERENCED_COLUMN_NAME = 67;
+}

src/Parsing/ParserState.php

@@ -0,0 +1,331 @@
+<?php
+
+namespace JamesWildDev\DBMLParser\Parsing;
+
+use JamesWildDev\DBMLParser\Tokenization\TokenType;
+use JamesWildDev\DBMLParser\Tokenization\TokenizerState;
+
+/**
+ * Helpers for identifying the classes of tokens.
+ */
+class TokenIs
+{
+  /**
+   * Determines whether a token is meaningful (not a comment or white space).
+   * @param TokenType $type The type of the token.
+   * @return bool True when the token is meaningful (not a comment or white space), otherwise, false.
+   */
+  public static function meaningful($type)
+  {
+    return $type !== TokenType::WHITE_SPACE && $type !== TokenType::LINE_COMMENT && $type != TokenType::UNKNOWN;
+  }
+
+  /**
+   * Determines whether a token could be interpreted as an identifier (a bare word or a string literal).
+   * @param TokenType $type The type of the token.
+   * @return bool True when the token could be interpreted as an identifier (a bare word or a string literal), otherwise, false.
+   */
+  public static function anIdentifier($type, $content)
+  {
+    return (
+      $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER
+      && ! self::anOpeningBrace($type, $content)
+      && ! self::aClosingBrace($type, $content)
+      && ! self::anOpeningParenthesis($type, $content)
+      && ! self::aClosingParenthesis($type, $content)
+      && ! self::anOpeningBracket($type, $content)
+      && ! self::aClosingBracket($type, $content)
+      && ! self::aSemicolon($type, $content)
+      && ! self::aLessThanSymbol($type, $content)
+      && ! self::aGreaterThanSymbol($type, $content)
+      && ! self::aHyphen($type, $content)
+      && ! self::aComma($type, $content)
+      && ! self::aPeriod($type, $content)
+    ) || $type === TokenType::STRING_LITERAL;
+  }
+
+  /**
+   * Determines whether a token means "as".
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "as", otherwise, false.
+   */
+  public static function isAs($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'as';
+  }
+
+  /**
+   * Determines whether a token means "table".
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "table", otherwise, false.
+   */
+  public static function table($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'table';
+  }
+
+  /**
+   * Determines whether a token means "enum".
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "enum", otherwise, false.
+   */
+  public static function enum($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'enum';
+  }
+
+  /**
+   * Determines whether a token means "ref".
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "ref", otherwise, false.
+   */
+  public static function ref($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'ref';
+  }
+
+  /**
+   * Determines whether a token means "unique".
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "unique", otherwise, false.
+   */
+  public static function unique($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'unique';
+  }
+
+  /**
+   * Determines whether a token means "name".
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "name", otherwise, false.
+   */
+  public static function name($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'name';
+  }
+
+  /**
+   * Determines whether a token is an opening brace ("{").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is an opening brace ("{"), otherwise, false.
+   */
+  public static function anOpeningBrace($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === '{';
+  }
+
+  /**
+   * Determines whether a token is a closing brace ("}").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is a closing brace ("}"), otherwise, false.
+   */
+  public static function aClosingBrace($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === '}';
+  }
+
+  /**
+   * Determines whether a token is an opening bracket ("[").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is an opening brace ("["), otherwise, false.
+   */
+  public static function anOpeningBracket($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === '[';
+  }
+
+  /**
+   * Determines whether a token is a closing bracket ("]").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is a closing bracket ("]"), otherwise, false.
+   */
+  public static function aClosingBracket($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === ']';
+  }
+
+  /**
+   * Determines whether a token is an opening parenthesis ("(").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is an opening parenthesis ("("), otherwise, false.
+   */
+  public static function anOpeningParenthesis($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === '(';
+  }
+
+  /**
+   * Determines whether a token is a closing parenthesis (")").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is a closing parenthesis (")"), otherwise, false.
+   */
+  public static function aClosingParenthesis($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === ')';
+  }
+
+  /**
+   * Determines whether a token is a semicolon (":").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is a semicolon (":"), otherwise, false.
+   */
+  public static function aSemicolon($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === ':';
+  }
+
+  /**
+   * Determines whether a token is a less than symbol ("<").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is a less than symbol ("<"), otherwise, false.
+   */
+  public static function aLessThanSymbol($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === '<';
+  }
+
+  /**
+   * Determines whether a token is a greater than symbol (">").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is a grater than symbol (">"), otherwise, false.
+   */
+  public static function aGreaterThanSymbol($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === '>';
+  }
+
+  /**
+   * Determines whether a token is a hyphen ("-").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is a hyphen ("-"), otherwise, false.
+   */
+  public static function aHyphen($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === '-';
+  }
+
+  /**
+   * Determines whether a token is a comma (",").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is a comma (","), otherwise, false.
+   */
+  public static function aComma($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === ',';
+  }
+
+  /**
+   * Determines whether a token is a period (".").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token is a period ("."), otherwise, false.
+   */
+  public static function aPeriod($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && $content === '.';
+  }
+
+  /**
+   * Determines whether a token means "primary key" ("pk").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "primary key" ("pk"), otherwise, false.
+   */
+  public static function primaryKey($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'pk';
+  }
+
+  /**
+   * Determines whether a token means "auto increment" ("increment").
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "auto increment" ("increment"), otherwise, false.
+   */
+  public static function increment($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'increment';
+  }
+
+  /**
+   * Determines whether a token means "default".
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "default", otherwise, false.
+   */
+  public static function defaultKeyword($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'default';
+  }
+
+  /**
+   * Determines whether a token means "not".
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "not", otherwise, false.
+   */
+  public static function not($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'not';
+  }
+
+  /**
+   * Determines whether a token means "null".
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "null", otherwise, false.
+   */
+  public static function null($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'null';
+  }
+
+  /**
+   * Determines whether a token means "note".
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "note", otherwise, false.
+   */
+  public static function note($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'note';
+  }
+
+  /**
+   * Determines whether a token means "indexes".
+   * @param TokenType $type The type of the token.
+   * @param string $content The content of the token.
+   * @return bool True when the token means "indexes", otherwise, false.
+   */
+  public static function indexes($type, $content)
+  {
+    return $type === TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER && strtolower($content) === 'indexes';
+  }
+
+  /**
+   * Determines whether a token could be taken as a backtick string literal.
+   * @param TokenType $type The type of the token.
+   * @return bool True when the token could be taken as a backtick string literal, otherwise, false.
+   */
+  public static function aBacktickStringLiteral($type)
+  {
+    return $type === TokenType::BACKTICK_STRING_LITERAL;
+  }
+}

src/Parsing/TokenIs.php

@@ -0,0 +1,519 @@
+<?php
+
+namespace JamesWildDev\DBMLParser\Tests\Unit\Parsing;
+
+use JamesWildDev\DBMLParser\Parsing\Logging\ColumnCalculatedDefaultEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\ColumnConstantDefaultEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\ColumnEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\ColumnIncrementEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\ColumnNoteEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\ColumnNotNullEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\ColumnPrimaryKeyEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\EndOfFileEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\EnumEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\EnumValueEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\EnumValueNoteEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\IndexEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\LogParserTarget;
+use JamesWildDev\DBMLParser\Parsing\Logging\RefEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\TableAliasEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\TableEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\TableNoteEvent;
+use JamesWildDev\DBMLParser\Parsing\Logging\UnknownEvent;
+use JamesWildDev\DBMLParser\Parsing\Parser;
+use JamesWildDev\DBMLParser\Parsing\RefOperator;
+use JamesWildDev\DBMLParser\Tokenization\TokenType;
+use JamesWildDev\DBMLParser\Tokenization\Tokenizer;
+use JamesWildDev\DBMLParser\Tokenization\Logging\TokenEvent;;
+use PHPUnit\Framework\TestCase;
+
+final class ParserTest extends TestCase
+{
+  public function test_empty_file()
+  {
+    $logParserTarget = new LogParserTarget();
+    $parser = new Parser($logParserTarget);
+
+    $parser->endOfFile(1, 1);
+
+    $this->assertEquals([new EndOfFileEvent(true)], $logParserTarget->events);
+  }
+
+  public function test_non_empty_file()
+  {
+    $logParserTarget = new LogParserTarget();
+    $parser = new Parser($logParserTarget);
+    $tokenizer = new Tokenizer($parser);
+
+    foreach (str_split("
+      tABlE table_a_name as table_a_alias {
+        column_a_name column_a_type
+        column_b_name column_b_type(column_b_size)
+        column_c_name column_c_type [pk]
+        column_d_name column_d_type [increment]
+        column_e_name column_e_type [default: 'column e default']
+        column_f_name column_f_type [default: `column f default`]
+        column_g_name column_g_type [not null] /
+        column_h_name column_h_type [note: 'column h note']
+        column_i_name column_i_type [ref: > column_i_ref_table.column_i_ref_column]
+        column_j_name column_j_type [ref: < column_j_ref_table.column_j_ref_column] ]->
+        column_k_name column_k_type [ref: - column_k_ref_table.column_k_ref_column]
+        'column_l_name' column_l_type // Comments are ignored.
+        column_m_name column_m_type [ref: > 'column_m_ref_table'.column_m_ref_column]
+        column_n_name column_n_type [ref: > column_n_ref_table.'column_n_ref_column']
+        column_o_name column_o_type [unique]
+        column_p_name column_p_type [default: column_p_default]
+        IndeXES {
+          index_a_column_a
+          (index_b_column_a)
+          (index_c_column_a, index_c_column_b)
+          (index_d_column_a, index_d_column_b, index_d_column_c)
+          index_e_column_a [name: 'test index e name']
+          index_f_column_a [unique]
+          index_g_column_a [name: 'test index g name', unique]
+          'index_h_column_a'
+          ('index_i_column_a', 'index_i_column_b', 'index_i_column_c')
+        }
+        NoTE: 'table_a_note'
+      }
+
+      rEF: ref_a_table_a.ref_a_column_a > ref_a_table_b.ref_a_column_b
+      REf: ref_b_table_a.ref_b_column_a < ref_b_table_b.ref_b_column_b
+      ReF: ref_c_table_a.ref_c_column_a - ref_c_table_b.ref_c_column_b
+      rEf: 'ref_d_table_a'.ref_d_column_a > ref_d_table_b.ref_d_column_b
+      ref: ref_e_table_a.'ref_e_column_a' > ref_e_table_b.ref_e_column_b
+      REF: ref_f_table_a.ref_f_column_a > 'ref_f_table_b'.ref_f_column_b
+      ref: ref_g_table_a.ref_g_column_a > ref_g_table_b.'ref_g_column_b'
+
+      eNuM enum_a_name {
+        enum_a_value_a
+        'enum_a_value_b'
+        enum_a_value_c [note: 'enum_a_value_c_note']
+      }
+
+      ENum 'enum_b_name' {}
+
+      TABle 'table_b_name' {}
+      tabLE table_c_name as 'table_c_alias' {
+        NoTE { 'table_c_note' }
+      }
+
+      rEF { ref_h_table_a.ref_h_column_a > ref_h_table_b.ref_h_column_b }
+      REf { ref_i_table_a.ref_i_column_a < ref_i_table_b.ref_i_column_b }
+      ReF { ref_j_table_a.ref_j_column_a - ref_j_table_b.ref_j_column_b }
+      rEf { 'ref_k_table_a'.ref_k_column_a > ref_k_table_b.ref_k_column_b }
+      ref { ref_l_table_a.'ref_l_column_a' > ref_l_table_b.ref_l_column_b }
+      REF { ref_m_table_a.ref_m_column_a > 'ref_m_table_b'.ref_m_column_b }
+      ref { ref_n_table_a.ref_n_column_a > ref_n_table_b.'ref_n_column_b' }
+
+      unexpected
+
+      table with_empty_column_attributes { name_of_column_with_empty_attributes type_of_column_with_empty_attributes [] }
+      table with_all_attributes_in_one_column { name_of_column_with_all_attributes type_of_column_with_all_attributes [pk, increment, not null, note: 'example note', unique, default: 'example default', ref: > other_table_name.other_column_name, default: `other example default`, unique] }
+      table which_tests_index_edge_cases {
+        indexes {}
+        indexes {(abc, def, ghi) [unique, name: 'example name']}
+      }
+      enum which_tests_edge_cases { example_value_name }
+      table which_tests_column_edge_cases {
+        example_column_name_a example_column_type_a(example_column_size_a) [note: example_column_note_a]
+        example_column_name_b example_column_type_b
+      }
+      table which_tests_additional_column_edge_cases {
+        example_column_name_a example_column_type_a(example_column_size_a)
+      }
+    ") as $character) {
+      $tokenizer->character($character);
+    }
+    $tokenizer->endOfFile();
+
+    $this->assertEquals([
+      new TableEvent('table_a_name', 2, 13, 2, 24),
+      new TableAliasEvent('table_a_name', 'table_a_alias', 2, 29, 2, 41),
+      new ColumnEvent('table_a_name', 'column_a_name', 3, 9, 3, 21, 'column_a_type', null),
+      new ColumnEvent('table_a_name', 'column_b_name', 4, 9, 4, 21, 'column_b_type', 'column_b_size'),
+      new ColumnEvent('table_a_name', 'column_c_name', 5, 9, 5, 21, 'column_c_type', null),
+      new ColumnPrimaryKeyEvent('table_a_name', 'column_c_name'),
+      new ColumnEvent('table_a_name', 'column_d_name', 6, 9, 6, 21, 'column_d_type', null),
+      new ColumnIncrementEvent('table_a_name', 'column_d_name'),
+      new ColumnEvent('table_a_name', 'column_e_name', 7, 9, 7, 21, 'column_e_type', null),
+      new ColumnConstantDefaultEvent('table_a_name', 'column_e_name', 'column e default', 7, 47, 7, 64),
+      new ColumnEvent('table_a_name', 'column_f_name', 8, 9, 8, 21, 'column_f_type', null),
+      new ColumnCalculatedDefaultEvent('table_a_name', 'column_f_name', 'column f default', 8, 47, 8, 64),
+      new ColumnEvent('table_a_name', 'column_g_name', 9, 9, 9, 21, 'column_g_type', null),
+      new ColumnNotNullEvent('table_a_name', 'column_g_name'),
+      new ColumnEvent('table_a_name', 'column_h_name', 10, 9, 10, 21, 'column_h_type', null),
+      new ColumnNoteEvent('table_a_name', 'column_h_name', 'column h note', 10, 44, 10, 58),
+      new ColumnEvent('table_a_name', 'column_i_name', 11, 9, 11, 21, 'column_i_type', null),
+      new RefEvent('table_a_name', 2, 13, 2, 24, 'column_i_name', 11, 9, 11, 21, RefOperator::MANY_TO_ONE, 'column_i_ref_table', 11, 45, 11, 62, 'column_i_ref_column', 11, 64, 11, 82),
+      new ColumnEvent('table_a_name', 'column_j_name', 12, 9, 12, 21, 'column_j_type', null),
+      new RefEvent('table_a_name', 2, 13, 2, 24, 'column_j_name', 12, 9, 12, 21, RefOperator::ONE_TO_MANY, 'column_j_ref_table', 12, 45, 12, 62, 'column_j_ref_column', 12, 64, 12, 82),
+      new UnknownEvent([
+        new TokenEvent(TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER, 12, 85, 12, 85, ']', ']'),
+        new TokenEvent(TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER, 12, 86, 12, 86, '-', '-'),
+        new TokenEvent(TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER, 12, 87, 12, 87, '>', '>'),
+      ]),
+      new ColumnEvent('table_a_name', 'column_k_name', 13, 9, 13, 21, 'column_k_type', null),
+      new RefEvent('table_a_name', 2, 13, 2, 24, 'column_k_name', 13, 9, 13, 21, RefOperator::ONE_TO_ONE, 'column_k_ref_table', 13, 45, 13, 62, 'column_k_ref_column', 13, 64, 13, 82),
+      new ColumnEvent('table_a_name', 'column_l_name', 14, 9, 14, 23, 'column_l_type', null),
+      new ColumnEvent('table_a_name', 'column_m_name', 15, 9, 15, 21, 'column_m_type', null),
+      new RefEvent('table_a_name', 2, 13, 2, 24, 'column_m_name', 15, 9, 15, 21, RefOperator::MANY_TO_ONE, 'column_m_ref_table', 15, 45, 15, 64, 'column_m_ref_column', 15, 66, 15, 84),
+      new ColumnEvent('table_a_name', 'column_n_name', 16, 9, 16, 21, 'column_n_type', null),
+      new RefEvent('table_a_name', 2, 13, 2, 24, 'column_n_name', 16, 9, 16, 21, RefOperator::MANY_TO_ONE, 'column_n_ref_table', 16, 45, 16, 62, 'column_n_ref_column', 16, 64, 16, 84),
+      new ColumnEvent('table_a_name', 'column_o_name', 17, 9, 17, 21, 'column_o_type', null),
+      new IndexEvent('table_a_name', [
+        [
+          'name' => 'column_o_name',
+          'nameStartLine' => 17,
+          'nameStartColumn' => 9,
+          'nameEndLine' => 17,
+          'nameEndColumn' => 21,
+        ],
+      ], null, null, null, null, null, true),
+      new ColumnEvent('table_a_name', 'column_p_name', 18, 9, 18, 21, 'column_p_type', null),
+      new ColumnConstantDefaultEvent('table_a_name', 'column_p_name', 'column_p_default', 18, 47, 18, 62),
+      new IndexEvent('table_a_name', [
+        [
+          'name' => 'index_a_column_a',
+          'nameStartLine' => 20,
+          'nameStartColumn' => 11,
+          'nameEndLine' => 20,
+          'nameEndColumn' => 26,
+        ],
+      ], null, null, null, null, null, false),
+      new IndexEvent('table_a_name', [
+        [
+          'name' => 'index_b_column_a',
+          'nameStartLine' => 21,
+          'nameStartColumn' => 12,
+          'nameEndLine' => 21,
+          'nameEndColumn' => 27,
+        ],
+      ], null, null, null, null, null, false),
+      new IndexEvent('table_a_name', [
+        [
+          'name' => 'index_c_column_a',
+          'nameStartLine' => 22,
+          'nameStartColumn' => 12,
+          'nameEndLine' => 22,
+          'nameEndColumn' => 27,
+        ],
+        [
+          'name' => 'index_c_column_b',
+          'nameStartLine' => 22,
+          'nameStartColumn' => 30,
+          'nameEndLine' => 22,
+          'nameEndColumn' => 45,
+        ],
+      ], null, null, null, null, null, false),
+      new IndexEvent('table_a_name', [
+        [
+          'name' => 'index_d_column_a',
+          'nameStartLine' => 23,
+          'nameStartColumn' => 12,
+          'nameEndLine' => 23,
+          'nameEndColumn' => 27,
+        ],
+        [
+          'name' => 'index_d_column_b',
+          'nameStartLine' => 23,
+          'nameStartColumn' => 30,
+          'nameEndLine' => 23,
+          'nameEndColumn' => 45,
+        ],
+        [
+          'name' => 'index_d_column_c',
+          'nameStartLine' => 23,
+          'nameStartColumn' => 48,
+          'nameEndLine' => 23,
+          'nameEndColumn' => 63,
+        ],
+      ], null, null, null, null, null, false),
+      new IndexEvent('table_a_name', [
+        [
+          'name' => 'index_e_column_a',
+          'nameStartLine' => 24,
+          'nameStartColumn' => 11,
+          'nameEndLine' => 24,
+          'nameEndColumn' => 26,
+        ],
+      ], 'test index e name', 24, 35, 24, 53, false),
+      new IndexEvent('table_a_name', [
+        [
+          'name' => 'index_f_column_a',
+          'nameStartLine' => 25,
+          'nameStartColumn' => 11,
+          'nameEndLine' => 25,
+          'nameEndColumn' => 26,
+        ],
+      ], null, null, null, null, null, true),
+      new IndexEvent('table_a_name', [
+        [
+          'name' => 'index_g_column_a',
+          'nameStartLine' => 26,
+          'nameStartColumn' => 11,
+          'nameEndLine' => 26,
+          'nameEndColumn' => 26,
+        ],
+      ], 'test index g name', 26, 35, 26, 53, true),
+      new IndexEvent('table_a_name', [
+        [
+          'name' => 'index_h_column_a',
+          'nameStartLine' => 27,
+          'nameStartColumn' => 11,
+          'nameEndLine' => 27,
+          'nameEndColumn' => 28,
+        ],
+      ], null, null, null, null, null, false),
+      new IndexEvent('table_a_name', [
+        [
+          'name' => 'index_i_column_a',
+          'nameStartLine' => 28,
+          'nameStartColumn' => 12,
+          'nameEndLine' => 28,
+          'nameEndColumn' => 29,
+        ],
+        [
+          'name' => 'index_i_column_b',
+          'nameStartLine' => 28,
+          'nameStartColumn' => 32,
+          'nameEndLine' => 28,
+          'nameEndColumn' => 49,
+        ],
+        [
+          'name' => 'index_i_column_c',
+          'nameStartLine' => 28,
+          'nameStartColumn' => 52,
+          'nameEndLine' => 28,
+          'nameEndColumn' => 69,
+        ],
+      ], null, null, null, null, null, false),
+      new TableNoteEvent('table_a_name', 'table_a_note', 30, 15, 30, 28),
+      new RefEvent('ref_a_table_a', 33, 12, 33, 24, 'ref_a_column_a', 33, 26, 33, 39, RefOperator::MANY_TO_ONE, 'ref_a_table_b', 33, 43, 33, 55, 'ref_a_column_b', 33, 57, 33, 70),
+      new RefEvent('ref_b_table_a', 34, 12, 34, 24, 'ref_b_column_a', 34, 26, 34, 39, RefOperator::ONE_TO_MANY, 'ref_b_table_b', 34, 43, 34, 55, 'ref_b_column_b', 34, 57, 34, 70),
+      new RefEvent('ref_c_table_a', 35, 12, 35, 24, 'ref_c_column_a', 35, 26, 35, 39, RefOperator::ONE_TO_ONE, 'ref_c_table_b', 35, 43, 35, 55, 'ref_c_column_b', 35, 57, 35, 70),
+      new RefEvent('ref_d_table_a', 36, 12, 36, 26, 'ref_d_column_a', 36, 28, 36, 41, RefOperator::MANY_TO_ONE, 'ref_d_table_b', 36, 45, 36, 57, 'ref_d_column_b', 36, 59, 36, 72),
+      new RefEvent('ref_e_table_a', 37, 12, 37, 24, 'ref_e_column_a', 37, 26, 37, 41, RefOperator::MANY_TO_ONE, 'ref_e_table_b', 37, 45, 37, 57, 'ref_e_column_b', 37, 59, 37, 72),
+      new RefEvent('ref_f_table_a', 38, 12, 38, 24, 'ref_f_column_a', 38, 26, 38, 39, RefOperator::MANY_TO_ONE, 'ref_f_table_b', 38, 43, 38, 57, 'ref_f_column_b', 38, 59, 38, 72),
+      new RefEvent('ref_g_table_a', 39, 12, 39, 24, 'ref_g_column_a', 39, 26, 39, 39, RefOperator::MANY_TO_ONE, 'ref_g_table_b', 39, 43, 39, 55, 'ref_g_column_b', 39, 57, 39, 72),
+      new EnumEvent('enum_a_name', 41, 12, 41, 22),
+      new EnumValueEvent('enum_a_name', 'enum_a_value_a', 42, 9, 42, 22),
+      new EnumValueEvent('enum_a_name', 'enum_a_value_b', 43, 9, 43, 24),
+      new EnumValueEvent('enum_a_name', 'enum_a_value_c', 44, 9, 44, 22),
+      new EnumValueNoteEvent('enum_a_name', 'enum_a_value_c', 'enum_a_value_c_note', 44, 31, 44, 51),
+      new EnumEvent('enum_b_name', 47, 12, 47, 24),
+      new TableEvent('table_b_name', 49, 13, 49, 26),
+      new TableEvent('table_c_name', 50, 13, 50, 24),
+      new TableAliasEvent('table_c_name', 'table_c_alias', 50, 29, 50, 43),
+      new TableNoteEvent('table_c_name', 'table_c_note', 51, 16, 51, 29),
+      new RefEvent('ref_h_table_a', 54, 13, 54, 25, 'ref_h_column_a', 54, 27, 54, 40, RefOperator::MANY_TO_ONE, 'ref_h_table_b', 54, 44, 54, 56, 'ref_h_column_b', 54, 58, 54, 71),
+      new RefEvent('ref_i_table_a', 55, 13, 55, 25, 'ref_i_column_a', 55, 27, 55, 40, RefOperator::ONE_TO_MANY, 'ref_i_table_b', 55, 44, 55, 56, 'ref_i_column_b', 55, 58, 55, 71),
+      new RefEvent('ref_j_table_a', 56, 13, 56, 25, 'ref_j_column_a', 56, 27, 56, 40, RefOperator::ONE_TO_ONE, 'ref_j_table_b', 56, 44, 56, 56, 'ref_j_column_b', 56, 58, 56, 71),
+      new RefEvent('ref_k_table_a', 57, 13, 57, 27, 'ref_k_column_a', 57, 29, 57, 42, RefOperator::MANY_TO_ONE, 'ref_k_table_b', 57, 46, 57, 58, 'ref_k_column_b', 57, 60, 57, 73),
+      new RefEvent('ref_l_table_a', 58, 13, 58, 25, 'ref_l_column_a', 58, 27, 58, 42, RefOperator::MANY_TO_ONE, 'ref_l_table_b', 58, 46, 58, 58, 'ref_l_column_b', 58, 60, 58, 73),
+      new RefEvent('ref_m_table_a', 59, 13, 59, 25, 'ref_m_column_a', 59, 27, 59, 40, RefOperator::MANY_TO_ONE, 'ref_m_table_b', 59, 44, 59, 58, 'ref_m_column_b', 59, 60, 59, 73),
+      new RefEvent('ref_n_table_a', 60, 13, 60, 25, 'ref_n_column_a', 60, 27, 60, 40, RefOperator::MANY_TO_ONE, 'ref_n_table_b', 60, 44, 60, 56, 'ref_n_column_b', 60, 58, 60, 73),
+      new UnknownEvent([
+        new TokenEvent(TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER, 62, 7, 62, 16, 'unexpected', 'unexpected'),
+      ]),
+      new TableEvent('with_empty_column_attributes', 64, 13, 64, 40),
+      new ColumnEvent('with_empty_column_attributes', 'name_of_column_with_empty_attributes', 64, 44, 64, 79, 'type_of_column_with_empty_attributes', null),
+      new TableEvent('with_all_attributes_in_one_column', 65, 13, 65, 45),
+      new ColumnEvent('with_all_attributes_in_one_column', 'name_of_column_with_all_attributes', 65, 49, 65, 82, 'type_of_column_with_all_attributes', null),
+      new ColumnPrimaryKeyEvent('with_all_attributes_in_one_column', 'name_of_column_with_all_attributes'),
+      new ColumnIncrementEvent('with_all_attributes_in_one_column', 'name_of_column_with_all_attributes'),
+      new ColumnNotNullEvent('with_all_attributes_in_one_column', 'name_of_column_with_all_attributes'),
+      new ColumnNoteEvent('with_all_attributes_in_one_column', 'name_of_column_with_all_attributes', 'example note', 65, 151, 65, 164),
+      new IndexEvent(
+        'with_all_attributes_in_one_column',
+        [
+          [
+            'name' => 'name_of_column_with_all_attributes',
+            'nameStartLine' => 65,
+            'nameStartColumn' => 49,
+            'nameEndLine' => 65,
+            'nameEndColumn' => 82,
+          ],
+        ],
+        null,
+        null,
+        null,
+        null,
+        null,
+        true
+      ),
+      new ColumnConstantDefaultEvent('with_all_attributes_in_one_column', 'name_of_column_with_all_attributes', 'example default', 65, 184, 65, 200),
+      new RefEvent('with_all_attributes_in_one_column', 65, 13, 65, 45, 'name_of_column_with_all_attributes', 65, 49, 65, 82, RefOperator::MANY_TO_ONE, 'other_table_name', 65, 210, 65, 225, 'other_column_name', 65, 227, 65, 243),
+      new ColumnCalculatedDefaultEvent('with_all_attributes_in_one_column', 'name_of_column_with_all_attributes', 'other example default', 65, 255, 65, 277),
+      new IndexEvent(
+        'with_all_attributes_in_one_column',
+        [
+          [
+            'name' => 'name_of_column_with_all_attributes',
+            'nameStartLine' => 65,
+            'nameStartColumn' => 49,
+            'nameEndLine' => 65,
+            'nameEndColumn' => 82,
+          ],
+        ],
+        null,
+        null,
+        null,
+        null,
+        null,
+        true
+      ),
+      new TableEvent('which_tests_index_edge_cases', 66, 13, 66, 40),
+      new IndexEvent(
+        'which_tests_index_edge_cases',
+        [
+          [
+            'name' => 'abc',
+            'nameStartLine' => 68,
+            'nameStartColumn' => 19,
+            'nameEndLine' => 68,
+            'nameEndColumn' => 21,
+          ],
+          [
+            'name' => 'def',
+            'nameStartLine' => 68,
+            'nameStartColumn' => 24,
+            'nameEndLine' => 68,
+            'nameEndColumn' => 26,
+          ],
+          [
+            'name' => 'ghi',
+            'nameStartLine' => 68,
+            'nameStartColumn' => 29,
+            'nameEndLine' => 68,
+            'nameEndColumn' => 31,
+          ],
+        ],
+        'example name',
+        68,
+        49,
+        68,
+        62,
+        true
+      ),
+      new EnumEvent('which_tests_edge_cases', 70, 12, 70, 33),
+      new EnumValueEvent('which_tests_edge_cases', 'example_value_name', 70, 37, 70, 54),
+      new TableEvent('which_tests_column_edge_cases', 71, 13, 71, 41),
+      new ColumnEvent('which_tests_column_edge_cases', 'example_column_name_a', 72, 9, 72, 29, 'example_column_type_a', 'example_column_size_a'),
+      new ColumnNoteEvent('which_tests_column_edge_cases', 'example_column_name_a', 'example_column_note_a', 72, 83, 72, 103),
+      new ColumnEvent('which_tests_column_edge_cases', 'example_column_name_b', 73, 9, 73, 29, 'example_column_type_b', null),
+      new TableEvent('which_tests_additional_column_edge_cases', 75, 13, 75, 52),
+      new ColumnEvent('which_tests_additional_column_edge_cases', 'example_column_name_a', 76, 9, 76, 29, 'example_column_type_a', 'example_column_size_a'),
+      new EndOfFileEvent(true),
+    ], $logParserTarget->events);
+  }
+
+  public function test_file_with_interrupted_structure()
+  {
+    $logParserTarget = new LogParserTarget();
+    $parser = new Parser($logParserTarget);
+    $tokenizer = new Tokenizer($parser);
+
+    foreach (str_split("
+      tABlE table_a_name as table_a_alias {
+        column_a_name column_a_type
+        column_b_name column_b_type(column_b_size)
+        column_c_name column_c_type [pk]
+        column_d_name column_d_type [increment]
+        column_e_name column_e_type [default: 'column e default']
+        column_f_name column_f_type [default: `column f default`]
+        column_g_name column_g_type [not null] /
+        column_h_name column_h_type [note: 'column h note']
+        column_i_name column_i_type [ref: > column_i_ref_table.column_i_ref_column]
+        column_j_name column_j_type [ref: < column_j_ref_table.column_j_ref_column] ]->
+        column_k_name column_k_type [ref: - column_k_ref_table.column_k_ref_column]
+    ") as $character) {
+      $tokenizer->character($character);
+    }
+    $tokenizer->endOfFile();
+
+    $this->assertEquals([
+      new TableEvent('table_a_name', 2, 13, 2, 24),
+      new TableAliasEvent('table_a_name', 'table_a_alias', 2, 29, 2, 41),
+      new ColumnEvent('table_a_name', 'column_a_name', 3, 9, 3, 21, 'column_a_type', null),
+      new ColumnEvent('table_a_name', 'column_b_name', 4, 9, 4, 21, 'column_b_type', 'column_b_size'),
+      new ColumnEvent('table_a_name', 'column_c_name', 5, 9, 5, 21, 'column_c_type', null),
+      new ColumnPrimaryKeyEvent('table_a_name', 'column_c_name'),
+      new ColumnEvent('table_a_name', 'column_d_name', 6, 9, 6, 21, 'column_d_type', null),
+      new ColumnIncrementEvent('table_a_name', 'column_d_name'),
+      new ColumnEvent('table_a_name', 'column_e_name', 7, 9, 7, 21, 'column_e_type', null),
+      new ColumnConstantDefaultEvent('table_a_name', 'column_e_name', 'column e default', 7, 47, 7, 64),
+      new ColumnEvent('table_a_name', 'column_f_name', 8, 9, 8, 21, 'column_f_type', null),
+      new ColumnCalculatedDefaultEvent('table_a_name', 'column_f_name', 'column f default', 8, 47, 8, 64),
+      new ColumnEvent('table_a_name', 'column_g_name', 9, 9, 9, 21, 'column_g_type', null),
+      new ColumnNotNullEvent('table_a_name', 'column_g_name'),
+      new ColumnEvent('table_a_name', 'column_h_name', 10, 9, 10, 21, 'column_h_type', null),
+      new ColumnNoteEvent('table_a_name', 'column_h_name', 'column h note', 10, 44, 10, 58),
+      new ColumnEvent('table_a_name', 'column_i_name', 11, 9, 11, 21, 'column_i_type', null),
+      new RefEvent('table_a_name', 2, 13, 2, 24, 'column_i_name', 11, 9, 11, 21, RefOperator::MANY_TO_ONE, 'column_i_ref_table', 11, 45, 11, 62, 'column_i_ref_column', 11, 64, 11, 82),
+      new ColumnEvent('table_a_name', 'column_j_name', 12, 9, 12, 21, 'column_j_type', null),
+      new RefEvent('table_a_name', 2, 13, 2, 24, 'column_j_name', 12, 9, 12, 21, RefOperator::ONE_TO_MANY, 'column_j_ref_table', 12, 45, 12, 62, 'column_j_ref_column', 12, 64, 12, 82),
+      new UnknownEvent([
+        new TokenEvent(TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER, 12, 85, 12, 85, ']', ']'),
+        new TokenEvent(TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER, 12, 86, 12, 86, '-', '-'),
+        new TokenEvent(TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER, 12, 87, 12, 87, '>', '>'),
+      ]),
+      new ColumnEvent('table_a_name', 'column_k_name', 13, 9, 13, 21, 'column_k_type', null),
+      new RefEvent('table_a_name', 2, 13, 2, 24, 'column_k_name', 13, 9, 13, 21, RefOperator::ONE_TO_ONE, 'column_k_ref_table', 13, 45, 13, 62, 'column_k_ref_column', 13, 64, 13, 82),
+      new EndOfFileEvent(false),
+    ], $logParserTarget->events);
+  }
+
+  public function test_file_with_interrupted_invalid_characters()
+  {
+    $logParserTarget = new LogParserTarget();
+    $parser = new Parser($logParserTarget);
+    $tokenizer = new Tokenizer($parser);
+
+    foreach (str_split("
+      tABlE table_a_name as table_a_alias {
+        column_a_name column_a_type
+        column_b_name column_b_type(column_b_size)
+        column_c_name column_c_type [pk]
+        column_d_name column_d_type [increment]
+        column_e_name column_e_type [default: 'column e default']
+        column_f_name column_f_type [default: `column f default`]
+        column_g_name column_g_type [not null] /
+        column_h_name column_h_type [note: 'column h note']
+        column_i_name column_i_type [ref: > column_i_ref_table.column_i_ref_column]
+        column_j_name column_j_type [ref: < column_j_ref_table.column_j_ref_column] ]->
+    ") as $character) {
+      $tokenizer->character($character);
+    }
+    $tokenizer->endOfFile();
+
+    $this->assertEquals([
+      new TableEvent('table_a_name', 2, 13, 2, 24),
+      new TableAliasEvent('table_a_name', 'table_a_alias', 2, 29, 2, 41),
+      new ColumnEvent('table_a_name', 'column_a_name', 3, 9, 3, 21, 'column_a_type', null),
+      new ColumnEvent('table_a_name', 'column_b_name', 4, 9, 4, 21, 'column_b_type', 'column_b_size'),
+      new ColumnEvent('table_a_name', 'column_c_name', 5, 9, 5, 21, 'column_c_type', null),
+      new ColumnPrimaryKeyEvent('table_a_name', 'column_c_name'),
+      new ColumnEvent('table_a_name', 'column_d_name', 6, 9, 6, 21, 'column_d_type', null),
+      new ColumnIncrementEvent('table_a_name', 'column_d_name'),
+      new ColumnEvent('table_a_name', 'column_e_name', 7, 9, 7, 21, 'column_e_type', null),
+      new ColumnConstantDefaultEvent('table_a_name', 'column_e_name', 'column e default', 7, 47, 7, 64),
+      new ColumnEvent('table_a_name', 'column_f_name', 8, 9, 8, 21, 'column_f_type', null),
+      new ColumnCalculatedDefaultEvent('table_a_name', 'column_f_name', 'column f default', 8, 47, 8, 64),
+      new ColumnEvent('table_a_name', 'column_g_name', 9, 9, 9, 21, 'column_g_type', null),
+      new ColumnNotNullEvent('table_a_name', 'column_g_name'),
+      new ColumnEvent('table_a_name', 'column_h_name', 10, 9, 10, 21, 'column_h_type', null),
+      new ColumnNoteEvent('table_a_name', 'column_h_name', 'column h note', 10, 44, 10, 58),
+      new ColumnEvent('table_a_name', 'column_i_name', 11, 9, 11, 21, 'column_i_type', null),
+      new RefEvent('table_a_name', 2, 13, 2, 24, 'column_i_name', 11, 9, 11, 21, RefOperator::MANY_TO_ONE, 'column_i_ref_table', 11, 45, 11, 62, 'column_i_ref_column', 11, 64, 11, 82),
+      new ColumnEvent('table_a_name', 'column_j_name', 12, 9, 12, 21, 'column_j_type', null),
+      new RefEvent('table_a_name', 2, 13, 2, 24, 'column_j_name', 12, 9, 12, 21, RefOperator::ONE_TO_MANY, 'column_j_ref_table', 12, 45, 12, 62, 'column_j_ref_column', 12, 64, 12, 82),
+      new UnknownEvent([
+        new TokenEvent(TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER, 12, 85, 12, 85, ']', ']'),
+        new TokenEvent(TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER, 12, 86, 12, 86, '-', '-'),
+        new TokenEvent(TokenType::KEYWORD_SYMBOL_OR_IDENTIFIER, 12, 87, 12, 87, '>', '>'),
+      ]),
+      new EndOfFileEvent(false),
+    ], $logParserTarget->events);
+  }
+}