Skip to content

Commit

Permalink
Schema Definition Language Parser
Browse files Browse the repository at this point in the history 
This is a parser for the ad-hoc type definition language included in the
spec. This should also serve as a de-facto spec for the language.
Clearly once this is stable we should include it in the actual spec as
well.

This should end up being useful in a few contexts, including
client-side types and also a DSL for producing the JS type definitions
which can be tedious to write, and a way to specify acceptance tests.
(This would be a clear next step for this project)
  • Loading branch information
@schrockn-zz
schrockn-zz committed Jul 21, 2015
1 parent 33ed9aa commit 24ebe8c
Show file tree
Hide file tree
Showing 6 changed files with 1,044 additions and 191 deletions.
221 changes: 30 additions & 191 deletions src/language/parser.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,10 +9,11 @@

import { Source } from './source';
import { syntaxError } from '../error';
import { lex, TokenKind, getTokenKindDesc, getTokenDesc } from './lexer';
import type { Token } from './lexer';
import { TokenKind } from './lexer';
import type {
Name,
NamedType,
Type,
Variable,

Document,
Expand All @@ -33,9 +34,6 @@ import type {
ObjectField,

Directive,

Type,
NamedType
} from './ast';

import {
Expand Down Expand Up @@ -65,28 +63,23 @@ import {
DIRECTIVE,

NAMED_TYPE,
LIST_TYPE,
NON_NULL_TYPE,
LIST_TYPE,
} from './kinds';

/**
* Configuration options to control parser behavior
*/
type ParseOptions = {
/**
* By default, the parser creates AST nodes that know the location
* in the source that they correspond to. This configuration flag
* disables that behavior for performance or testing.
*/
noLocation?: boolean,

/**
* By default, the parser creates AST nodes that contain a reference
* to the source that they were created from. This configuration flag
* disables that behavior for performance or testing.
*/
noSource?: boolean,
}
import {
makeParser,
peek,
skip,
loc,
any,
many,
expect,
unexpected,
expectKeyword,
advance,
ParseOptions,
} from './parserCore';

/**
* Given a GraphQL source, parses it into a Document.
Expand All @@ -101,171 +94,6 @@ export function parse(
return parseDocument(parser);
}

/**
* Returns the parser object that is used to store state throughout the
* process of parsing.
*/
function makeParser(source: Source, options: ParseOptions) {
var _lexToken = lex(source);
return {
_lexToken,
source,
options,
prevEnd: 0,
token: _lexToken(),
};
}

/**
* Returns a location object, used to identify the place in
* the source that created a given parsed object.
*/
function loc(parser, start: number) {
if (parser.options.noLocation) {
return null;
}
if (parser.options.noSource) {
return {
start: start,
end: parser.prevEnd
};
}
return {
start: start,
end: parser.prevEnd,
source: parser.source
};
}

/**
* Moves the internal parser object to the next lexed token.
*/
function advance(parser): void {
var prevEnd = parser.token.end;
parser.prevEnd = prevEnd;
parser.token = parser._lexToken(prevEnd);
}

/**
* Determines if the next token is of a given kind
*/
function peek(parser, kind: string): boolean {
return parser.token.kind === kind;
}

/**
* If the next token is of the given kind, return true after advancing
* the parser. Otherwise, do not change the parser state and return false.
*/
function skip(parser, kind: string): boolean {
var match = parser.token.kind === kind;
if (match) {
advance(parser);
}
return match;
}

/**
* If the next token is of the given kind, return that token after advancing
* the parser. Otherwise, do not change the parser state and return false.
*/
function expect(parser, kind: string): Token {
var token = parser.token;
if (token.kind === kind) {
advance(parser);
return token;
}
throw syntaxError(
parser.source,
token.start,
`Expected ${getTokenKindDesc(kind)}, found ${getTokenDesc(token)}`
);
}

/**
* If the next token is a keyword with the given value, return that token after
* advancing the parser. Otherwise, do not change the parser state and return
* false.
*/
function expectKeyword(parser, value: string): Token {
var token = parser.token;
if (token.kind === TokenKind.NAME && token.value === value) {
advance(parser);
return token;
}
throw syntaxError(
parser.source,
token.start,
`Expected "${value}", found ${getTokenDesc(token)}`
);
}

/**
* Helper function for creating an error when an unexpected lexed token
* is encountered.
*/
function unexpected(parser, atToken?: ?Token): Error {
var token = atToken || parser.token;
return syntaxError(
parser.source,
token.start,
`Unexpected ${getTokenDesc(token)}`
);
}

/**
* Returns a possibly empty list of parse nodes, determined by
* the parseFn. This list begins with a lex token of openKind
* and ends with a lex token of closeKind. Advances the parser
* to the next lex token after the closing token.
*/
function any<T>(
parser,
openKind: number,
parseFn: (parser: any) => T,
closeKind: number
): Array<T> {
expect(parser, openKind);
var nodes = [];
while (!skip(parser, closeKind)) {
nodes.push(parseFn(parser));
}
return nodes;
}

/**
* Returns a non-empty list of parse nodes, determined by
* the parseFn. This list begins with a lex token of openKind
* and ends with a lex token of closeKind. Advances the parser
* to the next lex token after the closing token.
*/
function many<T>(
parser,
openKind: number,
parseFn: (parser: any) => T,
closeKind: number
): Array<T> {
expect(parser, openKind);
var nodes = [parseFn(parser)];
while (!skip(parser, closeKind)) {
nodes.push(parseFn(parser));
}
return nodes;
}

/**
* Converts a name lex token into a name parse node.
*/
function parseName(parser): Name {
var token = expect(parser, TokenKind.NAME);
return {
kind: NAME,
value: token.value,
loc: loc(parser, token.start)
};
}


// Implements the parsing rules in the Document section.

function parseDocument(parser): Document {
Expand Down Expand Up @@ -597,13 +425,24 @@ function parseDirective(parser): Directive {
};
}

/**
* Converts a name lex token into a name parse node.
*/
export function parseName(parser): Name {
var token = expect(parser, TokenKind.NAME);
return {
kind: NAME,
value: token.value,
loc: loc(parser, token.start)
};
}

// Implements the parsing rules in the Types section.

/**
* Handles the Type: NamedType, ListType, and NonNullType parsing rules.
*/
function parseType(parser): Type {
export function parseType(parser): Type {
var start = parser.token.start;
var type;
if (skip(parser, TokenKind.BRACKET_L)) {
Expand All @@ -627,7 +466,7 @@ function parseType(parser): Type {
return type;
}

function parseNamedType(parser): NamedType {
export function parseNamedType(parser): NamedType {
var start = parser.token.start;
return {
kind: NAMED_TYPE,
Expand Down
Loading

0 comments on commit 24ebe8c

Please sign in to comment.