# Ruby API

The `prism` gem provides a Ruby API for accessing the syntax tree.

For the most part, the API for accessing the tree mirrors that found in the [Syntax Tree](https://github.com/ruby-syntax-tree/syntax_tree) project. This means:

* Walking the tree involves creating a visitor and passing it to the `#accept` method on any node in the tree
* Nodes in the tree respond to named methods for accessing their children as well as `#child_nodes`
* Nodes respond to the pattern matching interfaces `#deconstruct` and `#deconstruct_keys`

Every entry in `config.yml` will generate a Ruby class as well as the code that builds the nodes themselves.
Creating a syntax tree involves calling one of the class methods on the `Prism` module.
The full API is documented below.

## API

* `Prism.dump(source)` - parse the syntax tree corresponding to the given source string, and serialize it to a string
* `Prism.dump_file(filepath)` - parse the syntax tree corresponding to the given source file and serialize it to a string
* `Prism.lex(source)` - parse the tokens corresponding to the given source string and return them as an array within a parse result
* `Prism.lex_file(filepath)` - parse the tokens corresponding to the given source file and return them as an array within a parse result
* `Prism.parse(source)` - parse the syntax tree corresponding to the given source string and return it within a parse result
* `Prism.parse_file(filepath)` - parse the syntax tree corresponding to the given source file and return it within a parse result
* `Prism.parse_stream(io)` - parse the syntax tree corresponding to the source that is read out of the given IO object using the `#gets` method and return it within a parse result
* `Prism.parse_lex(source)` - parse the syntax tree corresponding to the given source string and return it within a parse result, along with the tokens
* `Prism.parse_lex_file(filepath)` - parse the syntax tree corresponding to the given source file and return it within a parse result, along with the tokens
* `Prism.load(source, serialized)` - load the serialized syntax tree using the source as a reference into a syntax tree
* `Prism.parse_comments(source)` - parse the comments corresponding to the given source string and return them
* `Prism.parse_file_comments(source)` - parse the comments corresponding to the given source file and return them
* `Prism.parse_success?(source)` - parse the syntax tree corresponding to the given source string and return true if it was parsed without errors
* `Prism.parse_file_success?(filepath)` - parse the syntax tree corresponding to the given source file and return true if it was parsed without errors

## Nodes

Once you have nodes in hand coming out of a parse result, there are a number of common APIs that are available on each instance. They are:

* `#accept(visitor)` - a method that will immediately call `visit_*` to specialize for the node type
* `#child_nodes` - a positional array of the child nodes of the node, with `nil` values for any missing children
* `#compact_child_nodes` - a positional array of the child nodes of the node with no `nil` values
* `#copy(**keys)` - a method that allows creating a shallow copy of the node with the given keys overridden
* `#deconstruct`/`#deconstruct_keys(keys)` - the pattern matching interface for nodes
* `#inspect` - a string representation that looks like the syntax tree of the node
* `#location` - a `Location` object that describes the location of the node in the source file
* `#to_dot` - convert the node's syntax tree into graphviz dot notation
* `#type` - a symbol that represents the type of the node, useful for quick comparisons
