ilib-lint 1.0.0

package/docs/ilibLint.md

@@ -0,0 +1,1013 @@
+## Classes
+
+<dl>
+<dt><a href="#Formatter">Formatter</a></dt>
+<dd><p>Represent an output formatter</p>
+</dd>
+<dt><a href="#FormatterFactory">FormatterFactory</a></dt>
+<dd><p>Represent an output formatter</p>
+</dd>
+<dt><a href="#Parser">Parser</a></dt>
+<dd><p>common SPI for parser plugins</p>
+</dd>
+<dt><a href="#Plugin">Plugin</a></dt>
+<dd><p>common SPI that all plugins must implement</p>
+</dd>
+<dt><a href="#PluginManager">PluginManager</a></dt>
+<dd><p>Represent a plugin manager, which loads a list of plugins
+and then maintains references to them</p>
+</dd>
+<dt><a href="#Result">Result</a></dt>
+<dd><p>Represent an ilib-lint rule check result</p>
+</dd>
+<dt><a href="#Rule">Rule</a></dt>
+<dd><p>Represent an ilib-lint rule.</p>
+</dd>
+<dt><a href="#RuleSet">RuleSet</a></dt>
+<dd><p>Represent a set of ilib-lint rules.</p>
+</dd>
+<dt><a href="#SourceFile">SourceFile</a></dt>
+<dd><p>Represent a set of ilib-lint rules.</p>
+</dd>
+<dt><a href="#AnsiConsoleFormatter">AnsiConsoleFormatter</a></dt>
+<dd><p>Represent an output formatter for an ANSI console/terminal</p>
+</dd>
+<dt><a href="#XliffParser">XliffParser</a></dt>
+<dd><p>common SPI for parser plugins</p>
+</dd>
+<dt><a href="#XliffPlugin">XliffPlugin</a></dt>
+<dd><p>Plugin that can parse XLIFF files</p>
+</dd>
+<dt><a href="#ResourceICUPlurals">ResourceICUPlurals</a></dt>
+<dd><p>Represent an ilib-lint rule.</p>
+</dd>
+<dt><a href="#ResourceQuoteStyle">ResourceQuoteStyle</a></dt>
+<dd><p>Represent an ilib-lint rule.</p>
+</dd>
+<dt><a href="#ResourceRegExpChecker">ResourceRegExpChecker</a></dt>
+<dd><p>Resource checker class that checks that any regular expressions
+that matches in the source also appears in the translation.</p>
+</dd>
+<dt><a href="#ResourceUniqueKeys">ResourceUniqueKeys</a></dt>
+<dd><p>Represent an ilib-lint rule.</p>
+</dd>
+</dl>
+
+## Functions
+
+<dl>
+<dt><a href="#ParserFactory">ParserFactory()</a></dt>
+<dd><p>Return a list of parsers for the given file name extension</p>
+</dd>
+<dt><a href="#walk">walk(root, options)</a> ⇒ <code><a href="#SourceFile">Array.&lt;SourceFile&gt;</a></code></dt>
+<dd><p>Recursively walk a directory and return a list of files and directories
+within that directory. The walk is controlled via a list of exclude and
+include patterns. Each pattern should be a micromatch pattern like this:</p>
+<code>
+"*.json"
+</code>
+
+<p>The full path to every file and directory in the top-level directory will
+be included, unless it matches an exclude pattern, it which case, it will be
+excluded from the output. However, if the path
+also matches an include pattern, it will still be included nonetheless. The
+idea is that you can exclude a whole category of files (like all json files),
+but include specific ones. For example, you may exclude all json files, but
+still want to include the &quot;config.json&quot; file.<p>
+The options parameter may include any of the following optional properties:</p>
+<ul>
+<li><i>quiet</i> (boolean) - whether or not to give output while walking
+the directory tree
+<li><i>excludes</i> (Array of strings) - A list of micromatch patterns to
+exclude from the output. If a pattern matches a directory, that directory
+will not be recursively searched.
+<li><i>includes</i> (Array of strings) - A list of micromatch patterns to
+include in the walk. If a pattern matches both an exclude and an include, the
+include will override the exclude.
+</ul></dd>
+</dl>
+
+<a name="Formatter"></a>
+
+## *Formatter*
+Represent an output formatter
+
+**Kind**: global abstract class  
+
+* *[Formatter](#Formatter)*
+    * *[new Formatter()](#new_Formatter_new)*
+    * *[.getName()](#Formatter+getName) ⇒ <code>String</code>*
+    * *[.getDescription()](#Formatter+getDescription) ⇒ <code>String</code>*
+    * **[.format(result)](#Formatter+format) ⇒ <code>String</code>**
+
+
+* * *
+
+<a name="new_Formatter_new"></a>
+
+### *new Formatter()*
+Construct an formatter instance. Formatters and formatter plugins
+should implement this abstract class.
+
+
+* * *
+
+<a name="Formatter+getName"></a>
+
+### *formatter.getName() ⇒ <code>String</code>*
+Get the name of the formatter. This should be a unique string.
+
+**Kind**: instance method of [<code>Formatter</code>](#Formatter)  
+**Returns**: <code>String</code> - the name of this formatter  
+
+* * *
+
+<a name="Formatter+getDescription"></a>
+
+### *formatter.getDescription() ⇒ <code>String</code>*
+Return a general description of the formatter for use in help output.
+
+**Kind**: instance method of [<code>Formatter</code>](#Formatter)  
+**Returns**: <code>String</code> - a general description of the formatter  
+
+* * *
+
+<a name="Formatter+format"></a>
+
+### **formatter.format(result) ⇒ <code>String</code>**
+Format the given result with the current formatter and return the
+formatted string.
+
+**Kind**: instance abstract method of [<code>Formatter</code>](#Formatter)  
+**Returns**: <code>String</code> - the formatted result  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| result | [<code>Result</code>](#Result) | the result to format |
+
+
+* * *
+
+<a name="FormatterFactory"></a>
+
+## *FormatterFactory*
+Represent an output formatter
+
+**Kind**: global abstract class  
+
+* * *
+
+<a name="Parser"></a>
+
+## *Parser*
+common SPI for parser plugins
+
+**Kind**: global abstract class  
+
+* *[Parser](#Parser)*
+    * *[new Parser()](#new_Parser_new)*
+    * **[.init()](#Parser+init)**
+    * *[.parse()](#Parser+parse)*
+    * *[.getResources()](#Parser+getResources) ⇒ <code>Array.&lt;Resource&gt;</code>*
+
+
+* * *
+
+<a name="new_Parser_new"></a>
+
+### *new Parser()*
+Construct a new plugin.
+
+
+* * *
+
+<a name="Parser+init"></a>
+
+### **parser.init()**
+Initialize the current plugin,
+
+**Kind**: instance abstract method of [<code>Parser</code>](#Parser)  
+
+* * *
+
+<a name="Parser+parse"></a>
+
+### *parser.parse()*
+Parse the current file into an intermediate representation.
+
+**Kind**: instance method of [<code>Parser</code>](#Parser)  
+
+* * *
+
+<a name="Parser+getResources"></a>
+
+### *parser.getResources() ⇒ <code>Array.&lt;Resource&gt;</code>*
+For a "resource" type of plugin, this returns a list of Resource instances
+that result from parsing the file.
+
+**Kind**: instance method of [<code>Parser</code>](#Parser)  
+**Returns**: <code>Array.&lt;Resource&gt;</code> - list of Resource instances in this file  
+
+* * *
+
+<a name="Plugin"></a>
+
+## *Plugin*
+common SPI that all plugins must implement
+
+**Kind**: global abstract class  
+
+* *[Plugin](#Plugin)*
+    * *[new Plugin()](#new_Plugin_new)*
+    * **[.init()](#Plugin+init)**
+    * **[.getType()](#Plugin+getType) ⇒ <code>String</code>**
+    * *[.getExtensions()](#Plugin+getExtensions) ⇒ <code>Array.&lt;String&gt;</code>*
+    * *[.getRules()](#Plugin+getRules) ⇒ [<code>Array.&lt;Rule&gt;</code>](#Rule)*
+    * *[.getParsers()](#Plugin+getParsers) ⇒ [<code>Array.&lt;Parser&gt;</code>](#Parser)*
+    * *[.getFormatters()](#Plugin+getFormatters) ⇒ [<code>Array.&lt;Formatter&gt;</code>](#Formatter)*
+
+
+* * *
+
+<a name="new_Plugin_new"></a>
+
+### *new Plugin()*
+Construct a new plugin.
+
+
+* * *
+
+<a name="Plugin+init"></a>
+
+### **plugin.init()**
+Initialize the current plugin,
+
+**Kind**: instance abstract method of [<code>Plugin</code>](#Plugin)  
+
+* * *
+
+<a name="Plugin+getType"></a>
+
+### **plugin.getType() ⇒ <code>String</code>**
+Return the type of this plugin. This can be one of the
+following:
+
+<ul>
+<li>rule - this plugin implements a new rules
+<li>parser - this plugin knows how to parse files more deeply
+than line-by-line
+<li>formatter - this plugin formats results for a particular
+type of output
+</ul>
+
+**Kind**: instance abstract method of [<code>Plugin</code>](#Plugin)  
+**Returns**: <code>String</code> - tells what type of plugin this is  
+
+* * *
+
+<a name="Plugin+getExtensions"></a>
+
+### *plugin.getExtensions() ⇒ <code>Array.&lt;String&gt;</code>*
+Return the list of extensions of the files that this parser handles.
+The extensions are listed without the dot. eg. ["json", "jsn"]
+
+**Kind**: instance method of [<code>Plugin</code>](#Plugin)  
+**Returns**: <code>Array.&lt;String&gt;</code> - a list of file name extensions  
+
+* * *
+
+<a name="Plugin+getRules"></a>
+
+### *plugin.getRules() ⇒ [<code>Array.&lt;Rule&gt;</code>](#Rule)*
+For a "rule" type of plugin, this returns a list of Rule instances
+that this plugin implements.
+
+**Kind**: instance method of [<code>Plugin</code>](#Plugin)  
+**Returns**: [<code>Array.&lt;Rule&gt;</code>](#Rule) - list of Rule instances implemented by this
+plugin  
+
+* * *
+
+<a name="Plugin+getParsers"></a>
+
+### *plugin.getParsers() ⇒ [<code>Array.&lt;Parser&gt;</code>](#Parser)*
+For a "parser" type of plugin, this returns a list of Parser classes
+that this plugin implements.
+
+**Kind**: instance method of [<code>Plugin</code>](#Plugin)  
+**Returns**: [<code>Array.&lt;Parser&gt;</code>](#Parser) - list of Parser classes implemented by this
+plugin  
+
+* * *
+
+<a name="Plugin+getFormatters"></a>
+
+### *plugin.getFormatters() ⇒ [<code>Array.&lt;Formatter&gt;</code>](#Formatter)*
+For a "formatter" type of plugin, this returns a list of Formatter
+instances that this plugin implements.
+
+**Kind**: instance method of [<code>Plugin</code>](#Plugin)  
+**Returns**: [<code>Array.&lt;Formatter&gt;</code>](#Formatter) - list of Formatter instances implemented by this
+plugin  
+
+* * *
+
+<a name="PluginManager"></a>
+
+## PluginManager
+Represent a plugin manager, which loads a list of plugins
+and then maintains references to them
+
+**Kind**: global class  
+
+* [PluginManager](#PluginManager)
+    * [new PluginManager()](#new_PluginManager_new)
+    * [.load(name)](#PluginManager+load) ⇒ <code>Promise</code>
+    * [.getHandlers(pathName, type)](#PluginManager+getHandlers) ⇒ [<code>Array.&lt;Plugin&gt;</code>](#Plugin)
+
+
+* * *
+
+<a name="new_PluginManager_new"></a>
+
+### new PluginManager()
+Construct a new plugin manager.
+
+
+* * *
+
+<a name="PluginManager+load"></a>
+
+### pluginManager.load(name) ⇒ <code>Promise</code>
+Load the named plugin.
+
+**Kind**: instance method of [<code>PluginManager</code>](#PluginManager)  
+**Returns**: <code>Promise</code> - a promise to load the named plugin.  
+**Accept**: [<code>Plugin</code>](#Plugin) the loaded plugin  
+**Reject**: the plugin could not be found or loaded  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| name | <code>String</code> | plugin to load |
+
+
+* * *
+
+<a name="PluginManager+getHandlers"></a>
+
+### pluginManager.getHandlers(pathName, type) ⇒ [<code>Array.&lt;Plugin&gt;</code>](#Plugin)
+Return an array of handlers that handle the given path name based
+on things like the file name extension.
+
+**Kind**: instance method of [<code>PluginManager</code>](#PluginManager)  
+**Returns**: [<code>Array.&lt;Plugin&gt;</code>](#Plugin) - an array of plugins that claim to handle
+the given path name  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| pathName | <code>String</code> | path to a file to match |
+| type | <code>String</code> | the type of plugin being sought |
+
+
+* * *
+
+<a name="Result"></a>
+
+## *Result*
+Represent an ilib-lint rule check result
+
+**Kind**: global abstract class  
+
+* * *
+
+<a name="new_Result_new"></a>
+
+### *new Result(fields)*
+Construct an ilib-lint rule check result. Rules should return this
+type when reporting issues in the source files. The fields can
+contain any of the following properties:
+
+- severity {String}: "warning" or "error" (required)
+- description {String}: description of the problem in the source file
+  (required)
+- pathName {String}: name of the file that the issue was found in (required)
+- rule {Rule}: the rule that generated this issue (required)
+- id {String}: key of a resource being checked
+- source {String}: for resource problems, this is the original source string
+- highlight {String}: highlighted text from the source file indicating
+  where the issue was. For resources, this is either the source or target
+  string, where-ever the problem occurred
+- lineNumber {Number}: line number in the source fie where the issue
+  was found
+- locale {String}: locale of associated with this issue
+
+Only the severity, description, pathName, and rule are required. All other
+properties are optional.
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| fields | <code>Object</code> | result fields |
+
+
+* * *
+
+<a name="Rule"></a>
+
+## *Rule*
+Represent an ilib-lint rule.
+
+**Kind**: global abstract class  
+
+* *[Rule](#Rule)*
+    * *[new Rule()](#new_Rule_new)*
+    * *[.getName()](#Rule+getName) ⇒ <code>String</code>*
+    * *[.getDescription()](#Rule+getDescription) ⇒ <code>String</code>*
+    * *[.getRuleType()](#Rule+getRuleType) ⇒ <code>String</code>*
+    * *[.match(options)](#Rule+match) ⇒ <code>Object</code> \| <code>Array.&lt;Object&gt;</code> \| <code>undefined</code>*
+
+
+* * *
+
+<a name="new_Rule_new"></a>
+
+### *new Rule()*
+Construct an ilib-lint rule. Rules in plugins should implement this
+abstract class.
+
+
+* * *
+
+<a name="Rule+getName"></a>
+
+### *rule.getName() ⇒ <code>String</code>*
+Get the name of the rule. This should be a string with a dash-separated
+set of words (kebab or dash case). Example: "resource-match-whitespace"
+
+**Kind**: instance method of [<code>Rule</code>](#Rule)  
+**Returns**: <code>String</code> - the name of this rule  
+
+* * *
+
+<a name="Rule+getDescription"></a>
+
+### *rule.getDescription() ⇒ <code>String</code>*
+Return a general description of the type of problems that this rule is
+testing for. This description is not related to particular matches, so
+it cannot be more specific. Examples:
+
+"translation should use the appropriate quote style"
+"parameters to the translation wrapper function must not be concatenated"
+"translation should match the whitespace of the source string"
+
+**Kind**: instance method of [<code>Rule</code>](#Rule)  
+**Returns**: <code>String</code> - a general description of the type of problems that this rule is
+testing for  
+
+* * *
+
+<a name="Rule+getRuleType"></a>
+
+### *rule.getRuleType() ⇒ <code>String</code>*
+Return the type of this rule. Rules can be organized into the following
+types:
+
+- A resource rule. This checks a translated resource with a source string
+  and a translation to a given locale. eg. a rule that checks that
+  substitution parameters that exist in the source string also are
+  given in the target string.
+- A line rule. This rule checks single lines of a file. eg. a rule to
+  check the parameters to a function call.
+- A multiline rule. This rule checks multiple lines at once to find
+  problems that may span multiple lines. For example, a rule to enforce
+  a policy that all translatable strings in a source file have an appropriate
+  translator's comment on them.
+- A multifile rule. This rule checks problems across multiple files. eg.
+  a rule to check that ids for translatable strings are unique across all
+  files.
+
+**Kind**: instance method of [<code>Rule</code>](#Rule)  
+**Returns**: <code>String</code> - a string with either "resource", "line", "multiline", or
+"multifile".  
+
+* * *
+
+<a name="Rule+match"></a>
+
+### *rule.match(options) ⇒ <code>Object</code> \| <code>Array.&lt;Object&gt;</code> \| <code>undefined</code>*
+Return whether or not this rule matches the input. The options object can
+contain any of the following properties:
+
+<ul>
+<li>locale - the locale against which this rule should be checked. Some rules
+are locale-sensitive, others not.
+<li>resource - the resource to test this rule against. For resource rules, this
+is a required property.
+<li>line - a single line of a file to test this rule against (for line rules)
+<li>lines - all the lines of a file to test this rule against (for multiline rules
+and multifile rules)
+<li>pathName - the name of the current file being matched in multifile rules.
+<li>parameters - (optional) parameters for this rule from the configuration file
+</ul>
+
+The return value from this method when a rule matches is an object with the
+following properties:
+
+<ul>
+<li>severity - the severity of this match. This can be one of the following:
+  <ul>
+  <li>suggestion - a suggestion of a better way to do things. The current way is
+  not incorrect, but probably not optimal
+  <li>warning - a problem that should be fixed, but which does not prevent
+  your app from operating internationally. This is more severe than a suggestion.
+  <li>error - a problem that must be fixed. This type of problem will prevent
+  your app from operating properly internationally and could possibly even
+  crash your app in some cases.
+  </ul>
+<li>description - a description of the problem to display to the user. In order
+to make the ilib-lint output useful, this description should attempt to make the
+following things clear:
+  <ul>
+  <li>What part is wrong
+  <li>Why it is wrong
+  <li>Suggestions on how to fix it
+  </ul>
+<li>lineNumber - the line number where the match occurred in multiline rules
+<li>highlight - the line where the problem occurred, highlighted with XML syntax
+(see below)
+</ul>
+
+For the `highlight` property, the line that has a problem is reproduced with
+XML tags around the problem part, if it is known. The tags are of the form
+&lt;eX&gt; where X is a digit starting with 0 and progressing to 9 for each
+subsequent problem. If the file type is XML already, the rest of the line will
+be XML-escaped first.<p>
+
+Example:<p>
+
+"const str = rb.getString(<e0>id</e0>);"<p>
+
+In this rule, `getString()` must be called with a static string in order for the
+loctool to be able to extract that string. The line above calls `getString()`
+with a variable named "id" as a parameter. The variable is highlighted with the
+e0 tag. Callers can then translate the open and close tags appropriately for
+the output device, such as ASCII escapes for a regular terminal, or HTML tags
+for a web-based device.
+
+**Kind**: instance method of [<code>Rule</code>](#Rule)  
+**Returns**: <code>Object</code> \| <code>Array.&lt;Object&gt;</code> \| <code>undefined</code> - an object describing the problem if the rule
+does match for this locale, or an array of such Objects if there are multiple
+problems with the same input, or undefined if the rule does not match  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| options | <code>Object</code> | The options object as per the description above |
+
+
+* * *
+
+<a name="RuleSet"></a>
+
+## RuleSet
+Represent a set of ilib-lint rules.
+
+**Kind**: global class  
+
+* [RuleSet](#RuleSet)
+    * [new RuleSet()](#new_RuleSet_new)
+    * [.addRule(rule)](#RuleSet+addRule)
+    * [.getRule(name)](#RuleSet+getRule) ⇒ [<code>Rule</code>](#Rule) \| <code>undefined</code>
+    * [.getRules(type)](#RuleSet+getRules) ⇒ [<code>Array.&lt;Rule&gt;</code>](#Rule)
+    * [.getSize()](#RuleSet+getSize) ⇒ <code>Number</code>
+
+
+* * *
+
+<a name="new_RuleSet_new"></a>
+
+### new RuleSet()
+Construct an ilib-lint rule set.
+
+
+* * *
+
+<a name="RuleSet+addRule"></a>
+
+### ruleSet.addRule(rule)
+**Kind**: instance method of [<code>RuleSet</code>](#RuleSet)  
+
+| Param | Type |
+| --- | --- |
+| rule | [<code>Rule</code>](#Rule) | 
+
+
+* * *
+
+<a name="RuleSet+getRule"></a>
+
+### ruleSet.getRule(name) ⇒ [<code>Rule</code>](#Rule) \| <code>undefined</code>
+Return the rule with the given name.
+
+**Kind**: instance method of [<code>RuleSet</code>](#RuleSet)  
+**Returns**: [<code>Rule</code>](#Rule) \| <code>undefined</code> - the rule with the given name or
+undefined if the rule is not known  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| name | <code>String</code> | name to search for |
+
+
+* * *
+
+<a name="RuleSet+getRules"></a>
+
+### ruleSet.getRules(type) ⇒ [<code>Array.&lt;Rule&gt;</code>](#Rule)
+Return all the rules of the given type in this set.
+
+**Kind**: instance method of [<code>RuleSet</code>](#RuleSet)  
+**Returns**: [<code>Array.&lt;Rule&gt;</code>](#Rule) - the list of rules of the requested type  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| type | <code>String</code> | to search for |
+
+
+* * *
+
+<a name="RuleSet+getSize"></a>
+
+### ruleSet.getSize() ⇒ <code>Number</code>
+Return the number of rules in this set.
+
+**Kind**: instance method of [<code>RuleSet</code>](#RuleSet)  
+**Returns**: <code>Number</code> - the number of rules in this set  
+
+* * *
+
+<a name="SourceFile"></a>
+
+## SourceFile
+Represent a set of ilib-lint rules.
+
+**Kind**: global class  
+
+* [SourceFile](#SourceFile)
+    * [new SourceFile()](#new_SourceFile_new)
+    * [.getFilePath()](#SourceFile+getFilePath) ⇒ <code>String</code>
+    * [.getLocaleFromPath()](#SourceFile+getLocaleFromPath) ⇒ <code>String</code>
+    * [.parse()](#SourceFile+parse) ⇒ <code>Object</code>
+    * [.getType()](#SourceFile+getType) ⇒ <code>String</code>
+    * [.findIssues(ruleset, locales)](#SourceFile+findIssues) ⇒ [<code>Array.&lt;Result&gt;</code>](#Result)
+
+
+* * *
+
+<a name="new_SourceFile_new"></a>
+
+### new SourceFile()
+Construct a source file instance
+The options parameter can contain any of the following properties:
+
+- filePath {String} path to the file
+- settings {Object} the settings from the ilib-lint config that
+  apply to this file
+
+
+* * *
+
+<a name="SourceFile+getFilePath"></a>
+
+### sourceFile.getFilePath() ⇒ <code>String</code>
+Return the file path for this source file.
+
+**Kind**: instance method of [<code>SourceFile</code>](#SourceFile)  
+**Returns**: <code>String</code> - the file path for this source file  
+
+* * *
+
+<a name="SourceFile+getLocaleFromPath"></a>
+
+### sourceFile.getLocaleFromPath() ⇒ <code>String</code>
+Return the locale gleaned from the file path using the template in
+the settings, or undefined if no locale could be found.
+
+**Kind**: instance method of [<code>SourceFile</code>](#SourceFile)  
+**Returns**: <code>String</code> - the locale gleaned from the path, or the empty
+string if no locale could be found.  
+
+* * *
+
+<a name="SourceFile+parse"></a>
+
+### sourceFile.parse() ⇒ <code>Object</code>
+Parse the current source file into a list of resources (in the case of
+resource files, or lines in the case of other types of files.
+
+**Kind**: instance method of [<code>SourceFile</code>](#SourceFile)  
+**Returns**: <code>Object</code> - the parsed representation of this file  
+
+* * *
+
+<a name="SourceFile+getType"></a>
+
+### sourceFile.getType() ⇒ <code>String</code>
+Return the type of this file, resource or line.
+
+**Kind**: instance method of [<code>SourceFile</code>](#SourceFile)  
+**Returns**: <code>String</code> - the type of this file  
+
+* * *
+
+<a name="SourceFile+findIssues"></a>
+
+### sourceFile.findIssues(ruleset, locales) ⇒ [<code>Array.&lt;Result&gt;</code>](#Result)
+Check the current file and return a list of issues found in this file.
+This method parses the source file and applies each rule in turn
+using the given locales.
+
+**Kind**: instance method of [<code>SourceFile</code>](#SourceFile)  
+**Returns**: [<code>Array.&lt;Result&gt;</code>](#Result) - a list of natch results  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ruleset | [<code>RuleSet</code>](#RuleSet) | a set of rules to apply |
+| locales | <code>Array.&lt;Locale&gt;</code> | a set of locales to apply |
+
+
+* * *
+
+<a name="AnsiConsoleFormatter"></a>
+
+## *AnsiConsoleFormatter*
+Represent an output formatter for an ANSI console/terminal
+
+**Kind**: global abstract class  
+
+* *[AnsiConsoleFormatter](#AnsiConsoleFormatter)*
+    * *[new AnsiConsoleFormatter()](#new_AnsiConsoleFormatter_new)*
+    * *[.getDescription()](#AnsiConsoleFormatter+getDescription) ⇒ <code>String</code>*
+    * **[.format(result)](#AnsiConsoleFormatter+format) ⇒ <code>String</code>**
+
+
+* * *
+
+<a name="new_AnsiConsoleFormatter_new"></a>
+
+### *new AnsiConsoleFormatter()*
+Construct an formatter instance.
+
+
+* * *
+
+<a name="AnsiConsoleFormatter+getDescription"></a>
+
+### *ansiConsoleFormatter.getDescription() ⇒ <code>String</code>*
+Return a general description of the formatter for use in help output.
+
+**Kind**: instance method of [<code>AnsiConsoleFormatter</code>](#AnsiConsoleFormatter)  
+**Returns**: <code>String</code> - a general description of the formatter  
+
+* * *
+
+<a name="AnsiConsoleFormatter+format"></a>
+
+### **ansiConsoleFormatter.format(result) ⇒ <code>String</code>**
+Format the given result with the current formatter and return the
+formatted string.
+
+**Kind**: instance abstract method of [<code>AnsiConsoleFormatter</code>](#AnsiConsoleFormatter)  
+**Returns**: <code>String</code> - the formatted result  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| result | [<code>Result</code>](#Result) | the result to format |
+
+
+* * *
+
+<a name="XliffParser"></a>
+
+## *XliffParser*
+common SPI for parser plugins
+
+**Kind**: global abstract class  
+
+* *[XliffParser](#XliffParser)*
+    * *[new XliffParser()](#new_XliffParser_new)*
+    * *[.parse()](#XliffParser+parse)*
+    * *[.getResources()](#XliffParser+getResources) ⇒ <code>Array.&lt;Resource&gt;</code>*
+
+
+* * *
+
+<a name="new_XliffParser_new"></a>
+
+### *new XliffParser()*
+Construct a new plugin.
+
+
+* * *
+
+<a name="XliffParser+parse"></a>
+
+### *xliffParser.parse()*
+Parse the current file into an intermediate representation.
+
+**Kind**: instance method of [<code>XliffParser</code>](#XliffParser)  
+
+* * *
+
+<a name="XliffParser+getResources"></a>
+
+### *xliffParser.getResources() ⇒ <code>Array.&lt;Resource&gt;</code>*
+For a "resource" type of plugin, this returns a list of Resource instances
+that result from parsing the file.
+
+**Kind**: instance method of [<code>XliffParser</code>](#XliffParser)  
+**Returns**: <code>Array.&lt;Resource&gt;</code> - list of Resource instances in this file  
+
+* * *
+
+<a name="XliffPlugin"></a>
+
+## XliffPlugin
+Plugin that can parse XLIFF files
+
+**Kind**: global class  
+
+* [XliffPlugin](#XliffPlugin)
+    * [.getType()](#XliffPlugin+getType)
+    * [.getExtensions()](#XliffPlugin+getExtensions)
+    * [.getParsers()](#XliffPlugin+getParsers) ⇒ [<code>Array.&lt;Parser&gt;</code>](#Parser)
+
+
+* * *
+
+<a name="XliffPlugin+getType"></a>
+
+### xliffPlugin.getType()
+**Kind**: instance method of [<code>XliffPlugin</code>](#XliffPlugin)  
+
+* * *
+
+<a name="XliffPlugin+getExtensions"></a>
+
+### xliffPlugin.getExtensions()
+**Kind**: instance method of [<code>XliffPlugin</code>](#XliffPlugin)  
+
+* * *
+
+<a name="XliffPlugin+getParsers"></a>
+
+### xliffPlugin.getParsers() ⇒ [<code>Array.&lt;Parser&gt;</code>](#Parser)
+For a "parser" type of plugin, this returns a list of Parser classes
+that this plugin implements.
+
+**Kind**: instance method of [<code>XliffPlugin</code>](#XliffPlugin)  
+**Returns**: [<code>Array.&lt;Parser&gt;</code>](#Parser) - list of Parser classes implemented by this
+plugin  
+
+* * *
+
+<a name="ResourceICUPlurals"></a>
+
+## ResourceICUPlurals
+Represent an ilib-lint rule.
+
+**Kind**: global class  
+
+* * *
+
+<a name="ResourceICUPlurals+match"></a>
+
+### resourceICUPlurals.match()
+**Kind**: instance method of [<code>ResourceICUPlurals</code>](#ResourceICUPlurals)  
+
+* * *
+
+<a name="ResourceQuoteStyle"></a>
+
+## ResourceQuoteStyle
+Represent an ilib-lint rule.
+
+**Kind**: global class  
+
+* * *
+
+<a name="ResourceQuoteStyle+match"></a>
+
+### resourceQuoteStyle.match()
+**Kind**: instance method of [<code>ResourceQuoteStyle</code>](#ResourceQuoteStyle)  
+
+* * *
+
+<a name="ResourceRegExpChecker"></a>
+
+## ResourceRegExpChecker
+Resource checker class that checks that any regular expressions
+that matches in the source also appears in the translation.
+
+**Kind**: global class  
+
+* [ResourceRegExpChecker](#ResourceRegExpChecker)
+    * [new ResourceRegExpChecker()](#new_ResourceRegExpChecker_new)
+    * [.match()](#ResourceRegExpChecker+match)
+
+
+* * *
+
+<a name="new_ResourceRegExpChecker_new"></a>
+
+### new ResourceRegExpChecker()
+Construct a new regular expression-based resource checker.
+
+The options must contain the following required properties:
+
+- name - a unique name for this rule
+- description - a one-line description of what this rule checks for.
+  Example: "Check that URLs in the source also appear in the target"
+- note - a one-line note that will be printed on screen when the
+  check fails. Example: "The URL {matchString} did not appear in the
+  the target." (Currently, matchString is the only replacement
+  param that is supported.)
+- regexps - an array of strings that encode regular expressions to
+  look for
+
+
+* * *
+
+<a name="ResourceRegExpChecker+match"></a>
+
+### resourceRegExpChecker.match()
+**Kind**: instance method of [<code>ResourceRegExpChecker</code>](#ResourceRegExpChecker)  
+
+* * *
+
+<a name="ResourceUniqueKeys"></a>
+
+## ResourceUniqueKeys
+Represent an ilib-lint rule.
+
+**Kind**: global class  
+
+* * *
+
+<a name="ResourceUniqueKeys+match"></a>
+
+### resourceUniqueKeys.match()
+**Kind**: instance method of [<code>ResourceUniqueKeys</code>](#ResourceUniqueKeys)  
+
+* * *
+
+<a name="ParserFactory"></a>
+
+## ParserFactory()
+Return a list of parsers for the given file name extension
+
+**Kind**: global function  
+
+* * *
+
+<a name="walk"></a>
+
+## walk(root, options) ⇒ [<code>Array.&lt;SourceFile&gt;</code>](#SourceFile)
+Recursively walk a directory and return a list of files and directories
+within that directory. The walk is controlled via a list of exclude and
+include patterns. Each pattern should be a micromatch pattern like this:
+
+<code>
+"*.json"
+</code>
+
+The full path to every file and directory in the top-level directory will
+be included, unless it matches an exclude pattern, it which case, it will be
+excluded from the output. However, if the path
+also matches an include pattern, it will still be included nonetheless. The
+idea is that you can exclude a whole category of files (like all json files),
+but include specific ones. For example, you may exclude all json files, but
+still want to include the "config.json" file.<p>
+The options parameter may include any of the following optional properties:
+
+<ul>
+<li><i>quiet</i> (boolean) - whether or not to give output while walking
+the directory tree
+<li><i>excludes</i> (Array of strings) - A list of micromatch patterns to
+exclude from the output. If a pattern matches a directory, that directory
+will not be recursively searched.
+<li><i>includes</i> (Array of strings) - A list of micromatch patterns to
+include in the walk. If a pattern matches both an exclude and an include, the
+include will override the exclude.
+</ul>
+
+**Kind**: global function  
+**Returns**: [<code>Array.&lt;SourceFile&gt;</code>](#SourceFile) - an array of file names in the directory, filtered
+by the the excludes and includes list  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| root | <code>String</code> | Directory to walk |
+| options | <code>Object</code> | Options controlling how this walk happens. (See the description for more details.) |
+
+
+* * *
+