NewToken() Name returns a string representation of the Token type.

coincident()

Position returns the position in the .gitignore file at which the matching pattern was defined.

match{}

Match returns true if the given path matches the name pattern. If the pattern is meant for directories only, and the path is not a directory, Match wi

err() NewError returns a new Error instance for the given error e and position p.

Underlying returns the underlying error, permitting direct comparison against the wrapped error.

read() unread returns the given runes to the stream, making them eligible to be read again. The runes are returned in the order given, so the last run

repostorytest{}

pattern() token returns a Token instance of the given type_ represented by word runes.

Base returns the directory containing the .gitignore file.

String returns a string representation of the matched pattern.

file()

String() private methods read the next rune from the stream. Return an Error if there is a problem reading from the stream. If the end of stream is

Ignore returns true if the match pattern describes files or paths that should be ignored.

Local()

exclude()

Relative attempts to match a path relative to the GitIgnore base directory. isdir is used to indicate whether the path represents a file or a director

do()

eol() next returns the next token from the Lexer, or an error if there is a problem reading from the input stream.

TestInvalidRepositoryWithCache() helper functions

TestNew()

Name() Token returns the string representation of the Token word.

create()

TestMatchRelative()

repository()

skip() undo returns the given Token t to the parser input stream to be retrieved again on a subsequent call to next.

Include returns true if the match pattern describes files or paths that should be included.

String() Zero returns true if the Position represents the zero Position

pos()

undo() err returns an Error for the error e, capturing the current parser Position.

Absolute attempts to match an absolute path against this GitIgnore. If the path is not located under the base directory of this GitIgnore, or is not m

Get attempts to retrieve an GitIgnore instance associated with the given path. If the path is not known nil is returned.

err() errors returns the response from the parser error handler to the Error e. If no error handler has been configured for this parser, errors return

TestLexerInvalidCarriageReturn()

Parse returns all well-formed .gitignore Patterns contained within the parser stream. Parsing will terminate at the end of the stream, or if the parse

Set stores the GitIgnore ignore against its path.

buffer()

whitespace() pattern returns all runes representing a file or path pattern, delimited either by unescaped whitespace, a path separator '/' or enf of f

unread() peek returns the next rune in the stream without consuming it (i.e. it will be returned by the next call to read or peek). peek will return a

invalid()

sequence() separator attempts to retrieve a valid sequence of tokens that may appear after the path separator '/' Token t. An Error is returned if the

Base() Match attempts to match the path against this GitIgnore, and will return its Match if successful. Match will invoke the GitIgnore error handler

any{} NewPattern returns a Pattern from the ordered slice of Tokens. The tokens are assumed to represent a well-formed .gitignore pattern. A Pattern m

NewFromFile() NewWithErrors creates a GitIgnore instance from the given file. If errors is given, it will be invoked for every error encountered when

Next returns the next Token from the Lexer reader. If an error is encountered, it will be returned as an Error instance, detailing the error and its p

Position returns the current position of the parser in the input stream.

Position returns the position of the error within the .gitignore file (if any)

Next() Position returns the current position of the Lexer.

String returns the string representation of the current position of the Lexer.

Token() String returns a string representation of the Token, encapsulating its position in the input stream, its name (i.e. type), and its runes.

String returns a string representation of the current position.

separator() any attempts to retrieve a valid sequence of tokens that may appear after the any '**' Token t. An Error is returned if the sequence if to

token() err returns an Error encapsulating the error e and the current Lexer position.

exclude attempts to return the GitIgnore instance for the $GIT_DIR/info/exclude from the working copy to which path belongs.

parse()

Match() match performs the recursive matching for 'any' patterns. An 'any' token '**' may match any path component, or no path component.

TestParserInvalidFalse()

any() pattern attempts to retrieve a valid sequence of tokens that may appear after the path pattern Token t. An Error is returned if the sequence if

path() sequence attempts to extract a well-formed Token sequence from the Lexer representing a .gitignore Pattern. sequence returns an Error if the re

next() skip reads Tokens from the input until the end of line or end of file is reached. If there is a problem reading tokens, an Error is returned.

Match() Absolute attempts to match an absolute path against this repository. If the path is not located under the base directory of this repository, o

Match() Absolute attempts to match an absolute path against this GitIgnore. If the path is not located under the base directory of this GitIgnore, or

Ignore returns true if the path is ignored by this GitIgnore. Paths that are not matched by this GitIgnore are not ignored. Internally, Ignore uses Ma

Include returns true if the path is included by this GitIgnore. Paths that are not matched by this GitIgnore are always included. Internally, Include

Match attempts to match the path against this GitIgnore, and will return its Match if successful. Match will invoke the GitIgnore error handler (if de

NewGitIgnore creates a new GitIgnore instance from the patterns listed in t, representing a .gitignore file in the base directory. If errors is given,

NewCache returns a Cache instance. This is a thread-safe, in-memory cache for GitIgnore instances.

New() NewFromFile creates a GitIgnore instance from the given file. An error will be returned if file cannot be opened or its absolute path determined

NewLexer returns a Lexer instance for the io.Reader r.

parser{} NewParser returns a new Parser instance for the given stream r. If err is not nil, it will be called for every error encountered during parsi

NewRepositoryWithErrors() NewRepositoryWithCache returns a GitIgnore instance representing a git repository with a root directory base. As with NewRep

NewRepositoryWithFile() NewRepositoryWithErrors returns a GitIgnore instance representing a git repository with a root directory base. As with NewRepo

NewRepository() NewRepositoryWithFile returns a GitIgnore instance representing a git repository with root directory base. The repository will use fil

NewToken returns a Token instance of the given t, represented by the word runes, at the stream position pos. If the token type is not know, the return

NewWithErrors() NewWithCache returns a GitIgnore instance (using NewWithErrors) for the given file. If the file has been loaded before, its GitIgnore

Next returns the next well-formed .gitignore Pattern from the parser stream. If an error is encountered, and the error handler is either not defined,

Parse() Next returns the next well-formed .gitignore Pattern from the parser stream. If an error is encountered, and the error handler is either not d

Next() Position returns the current position of the parser in the input stream.

Position returns the current position of the Lexer.

Absolute() Relative attempts to match a path relative to the repository base directory. If the path is not matched by the repository, nil is returned.

Absolute() Relative attempts to match a path relative to the GitIgnore base directory. isdir is used to indicate whether the path represents a file or

Match() "any" patterns any returns a Pattern designed to match paths that include at least one any pattern '**', specifying recursive matching.

err() beginning returns true if the Lexer is at the start of a new line.

Position() private methods build attempts to build a well-formed .gitignore Pattern starting from the given Token t. An Error will be returned if th

newline() comment reads all runes until a newline or end of file is reached. An error is returned if an error is encountered reading from the stream.

NewPattern() compile generates a specific Pattern (i.e. name, path or any) represented by the list of tokens.

pattern() eol attempts to consume the next Lexer token to read the end of line or end of file. If a EOL or EOF is not reached , eol will return an err

escape() eol returns all runes from the current position to the end of the line. An error is returned if there is a problem reading from the stream, o

comment() escape attempts to read an escape sequence (e.g. '\ ') form the input stream. An error will be returned if there is an error reading from th

name patterns - designed to match trailing file/directory names only name returns a Pattern designed to match file or directory names, with no path

build() negation attempts to build a well-formed negated .gitignore Pattern starting from the negation Token t. As with build, negation returns an Err

peek() newline adjusts the positional counters when an end of line is reached

negation() path attempts to build a well-formed .gitignore Pattern representing a path specification, starting with the Token t. If the sequence of to

Match() path patterns - designed to match complete or partial paths (not just filenames) path returns a Pattern designed to match paths that include

eol() whitespace returns all whitespace (i.e. ' ' and '\t') runes in a sequence, or an error if there is a problem reading the next runes.

NewWithCache() Base returns the directory containing the .gitignore file for this GitIgnore.

ExampleNewFromFile()