### Serve MkDocs Documentation Locally

Source: https://facelessuser.github.io/ApplySyntax/about/contributing

This command allows you to preview the documentation locally after installing the required packages. It starts a local web server at http://localhost:8000.

```bash
mkdocs serve
```

--------------------------------

### Apply Syntax with 'match: all' Rules (JSON)

Source: https://facelessuser.github.io/ApplySyntax/usage

This example demonstrates applying 'Handlebars/Handlebars' syntax when a file matches both a specific file path pattern ending in '.html' and contains a specific script type attribute for Handlebars.

```json
{
     "syntax": "Handlebars/Handlebars",
     "match": "all",
     "rules": [
         {"file_path": ".*\\.html$"},
         {"contains": "<script [^>]*type=\"text\\/x-handlebars"[^>]*>"
     ]
 }
```

--------------------------------

### Install Pytest for Unit Testing - Pip

Source: https://facelessuser.github.io/ApplySyntax/about/contributing

Installs the 'pytest' package, which is used to run unit tests for the ApplySyntax plugin. This command should be run using pip, Python's package installer.

```python
pip install pytest
```

--------------------------------

### Install Linting Tools - Pip

Source: https://facelessuser.github.io/ApplySyntax/about/contributing

Installs the necessary tools for linting the ApplySyntax project: 'flake8', 'flake8_docstrings', and 'pep8-naming'. These packages help maintain code quality and style adherence.

```python
pip install flake8
pip install flake8_docstrings
pip install pep8-naming
```

--------------------------------

### Apply Syntax with Multiple File Path Rules (JSON)

Source: https://facelessuser.github.io/ApplySyntax/usage

This configuration applies 'Ruby/Ruby' syntax if a file matches any of the specified file path patterns, such as 'Gemfile', 'Rakefile', or files ending in '.rb', or if the interpreter is 'ruby'. This example implies 'match' is not set to 'all', so only one rule needs to match.

```json
{
    "syntax": "Ruby/Ruby",
    "rules": [
        {"file_path": ".*/Gemfile$"},
        {"file_path": ".*/Capfile$"},
        {"file_path": ".*/Guardfile$"},
        {"file_path": ".*/[Rr]akefile$"},
        {"file_path": ".*/Berksfile$"},
        {"file_path": ".*/[Cc]heffile$"},
        {"file_path": ".*/Thorfile$"},
        {"file_path": ".*/Podfile$"},
        {"file_path": ".*/config.ru$"},
        {"file_path": ".*/Vagrantfile(/..*)?$"},
        {"file_path": ".*\\.thor$"},
        {"file_path": ".*\\.rake$"},
        {"file_path": ".*\\.simplecov$"},
        {"file_path": ".*\\.jbuilder$"},
        {"file_path": ".*\\.rb$"},
        {"file_path": ".*\\.podspec$"},
        {"file_path": ".*\\.rabl$"},
        {"interpreter": "ruby"
    ]
}
```

--------------------------------

### Force Syntax File Extension - ApplySyntax Rule

Source: https://facelessuser.github.io/ApplySyntax/usage

This example shows how to explicitly define the syntax file extension in an ApplySyntax rule. This is useful for forcing either '.sublime-syntax' or '.tmLanguage' if ApplySyntax's default fallback behavior is not desired.

```json
"syntax": "Rails/Language/Ruby Haml.tmLanguage"
```

--------------------------------

### Multiple Syntax Files - ApplySyntax Rule

Source: https://facelessuser.github.io/ApplySyntax/usage

This code illustrates how to define an array of syntax file paths in an ApplySyntax rule. The plugin will attempt to use the first syntax file found in the list, which is helpful when a syntax might exist in different packages.

```json
"syntax": ["RSpec/RSpec", "RSpec (snippets and syntax)/Syntaxes/RSpec"]
```

--------------------------------

### Globmatch Rule for Python Files (JSON)

Source: https://facelessuser.github.io/ApplySyntax/usage

A 'globmatch' rule uses glob patterns to match file paths. This example specifies a pattern to match all files ending with '.py'. The 'wcmatch' library is used with flags like GLOBSTAR, BRACE, EXTGLOB, NEGATE, and DOTGLOB enabled.

```json
{"globmatch": "**/*.py"}
```

--------------------------------

### Git Clone Repository Command

Source: https://facelessuser.github.io/ApplySyntax/installation

This command-line instruction demonstrates how to clone the ApplySyntax repository using Git. It navigates to the Sublime Text 3 Packages directory and then clones the specified repository into a folder named ApplySyntax. Ensure you replace '/path/to/Sublime Text 3/Packages' with the actual path on your system.

```bash
cd /path/to/Sublime Text 3/Packages
git clone https://github.com/facelessuser/ApplySyntax.git ApplySyntax
```

--------------------------------

### Set 'match: all' Rule (JSON)

Source: https://facelessuser.github.io/ApplySyntax/usage

The 'match: all' setting requires all defined rules within a syntax block to be met for a successful match. This setting ignores the 'extensions' key, and if file path matching is needed, a 'file_path' rule should be used instead.

```json
"match": "all"
```

--------------------------------

### Define Project Specific Syntaxes and Extension Trimming

Source: https://facelessuser.github.io/ApplySyntax/usage

This code snippet demonstrates how to define project-specific syntax rules and extension trimming by adding `project_syntaxes` and `project_ext_trim` keys within the `settings` object of a project file. `project_syntaxes` accepts an array of syntax objects, each with a `syntax` name and an array of `rules`. `project_ext_trim` accepts an array of objects with a `file_path` to trim. Project-specific rules are prepended to user and default rules, with order: project → user → default. Note that the `extensions` key is not applied to language settings files for project-specific rules.

```json
{
    "settings": {
        "project_syntaxes": [
            {
                "syntax": "XML/XML",
                "rules": [
                    {"file_path": ".*\\.xml(\\.dist)?$"},
                    {"first_line": "^<\\?xml"}
                ]
            }
        ],
        "project_ext_trim": [
            {"file_path": ".*\\.file.temp"}
        ]
    }

}
```

--------------------------------

### Match First Line of File Content

Source: https://facelessuser.github.io/ApplySyntax/usage

The `first_line` rule checks if the first line of a file's content matches a given regex. The pattern is always anchored to the beginning of the line. This is useful for specific file headers or directives.

```json
{"first_line": "^<\\?xml"}
```

--------------------------------

### Define Syntax Extensions (YAML)

Source: https://facelessuser.github.io/ApplySyntax/usage

The 'extensions' attribute specifies file extensions to associate with a syntax. It's an array of strings. If 'add_exts_to_lang_settings' is true, ApplySyntax can automatically update Sublime Text's language settings and maintain an extension list.

```json
{
    "syntax": "YAML/YAML",
    "extensions": [".gemrc", "yml", "yml.dist"]
}
```

--------------------------------

### ApplySyntax General Settings - New File Syntax

Source: https://facelessuser.github.io/ApplySyntax/usage

Specify a default syntax to be applied when new files are created. The `new_file_syntax` setting should be set to the name of the desired syntax (e.g., `JavaScript/JavaScript`). If set to `false`, no default syntax is applied. The default value is `false`.

```json
{
    "new_file_syntax": "JavaScript/JavaScript",

}
```

--------------------------------

### Match Interpreter Directive (Shebang)

Source: https://facelessuser.github.io/ApplySyntax/usage

The `interpreter` rule simplifies matching interpreter directives (shebang lines) compared to using `first_line` with a regex. The `binary` rule is accepted for backward compatibility. ApplySyntax constructs the regex automatically.

```json
{"first_line": "^#\\!(?:.+)?ruby"}
```

```json
{"interpreter": "ruby"}
```

--------------------------------

### Globmatch Rule with Exclusion (JSON)

Source: https://facelessuser.github.io/ApplySyntax/usage

This 'globmatch' rule demonstrates using a list of patterns, including an exclusion pattern ('!**/bad.py'), to match files. It will select all '.py' files except those located in 'bad.py'.

```json
{"globmatch": ["**/*.py", "!**/bad.py"]}
```

--------------------------------

### Add Dependency Python Function

Source: https://facelessuser.github.io/ApplySyntax/installation

This Python function, `add_dependency`, is used to add a specified dependency. It likely relies on a helper function `generate_dependency_paths` to resolve the path for the dependency and then adds it using the `add` function. It handles path encoding and allows for adding the dependency at the beginning of a list.

```python
def add_dependency(name, first=False):
    """
A unicode string name of the dependency

    :param first:
        If the path should be added to the beginning of the list
    """

    dep_paths = generate_dependency_paths(name)

    for path in dep_paths.values():
        if os.path.exists(encode(path)):
            add(path, first=first)


add_dependency('pygments')
add_dependency('markupsafe')
add_dependency('python-markdown')
add_dependency('python-jinja2')
add_dependency('mdpopups')
```

--------------------------------

### Globmatch Rule with Case Sensitivity (JSON)

Source: https://facelessuser.github.io/ApplySyntax/usage

This 'globmatch' rule specifies case sensitivity for matching file paths. The 'case: true' option ensures that the pattern '**/.*py' will only match file names with that exact casing.

```json
{"globmatch": "**/*.py", "case": true}
```

--------------------------------

### Python Script for Managing Sublime Text Dependencies

Source: https://facelessuser.github.io/ApplySyntax/installation

This Python script, `00-dependencies.py`, is designed to manage Python's `sys.path` for Sublime Text packages and their dependencies. It handles different Sublime Text versions (2 and 3), operating systems (Windows), and architectures, ensuring that necessary modules can be imported correctly. It provides functions to add and remove paths and to generate platform-specific dependency paths.

```python
import sys
import os
from os.path import dirname

if os.name == 'nt':
    from ctypes import windll, create_unicode_buffer

import sublime


if sys.version_info >= (3,):
    def decode(path):
        return path

    def encode(path):
        return path

    if os.path.basename(__file__) == 'sys_path.py':
        pc_package_path = dirname(dirname(__file__))
    # When loaded as a .sublime-package file, the filename ends up being
    # Package Control.sublime-package/Package Control.package_control.sys_path
    else:
        pc_package_path = dirname(__file__)
    st_version = u'3'

else:
    def decode(path):
        if not isinstance(path, unicode):
            path = path.decode(sys.getfilesystemencoding())
        return path

    def encode(path):
        if isinstance(path, unicode):
            path = path.encode(sys.getfilesystemencoding())
        return path

    pc_package_path = decode(os.getcwd())
    st_version = u'2'


st_dir = dirname(dirname(pc_package_path))


def add(path, first=False):
    """
    Adds an entry to the beginning of sys.path, working around the fact that
    Python 2.6 can't import from non-ASCII paths on Windows.

    :param path:
        A unicode string of a folder, zip file or sublime-package file to
        add to the path

    :param first:
        If the path should be added at the beginning
    """

    if os.name == 'nt':
        # Work around unicode path import issue on Windows with Python 2.6
        buf = create_unicode_buffer(512)
        if windll.kernel32.GetShortPathNameW(path, buf, len(buf)):
            path = buf.value

    enc_path = encode(path)

    if os.path.exists(enc_path):
        if first:
            try:
                sys.path.remove(enc_path)
            except (ValueError):
                pass
            sys.path.insert(0, enc_path)
        elif enc_path not in sys.path:
            sys.path.append(enc_path)


def remove(path):
    """
    Removes a path from sys.path if it is present

    :param path:
        A unicode string of a folder, zip file or sublime-package file
    """

    try:
        sys.path.remove(encode(path))
    except (ValueError):
        pass

    if os.name == 'nt':
        buf = create_unicode_buffer(512)
        if windll.kernel32.GetShortPathNameW(path, buf, len(buf)):
            path = buf.value
        try:
            sys.path.remove(encode(path))
        except (ValueError):
            pass


def generate_dependency_paths(name):
    """
    Accepts a dependency name and generates a dict containing the three standard
    import paths that are valid for the current machine.

    :param name:
        A unicode string name of the dependency

    :return:
        A dict with the following keys:
         - 'ver'
         - 'plat'
         - 'arch'
    """

    packages_dir = os.path.join(st_dir, u'Packages')
    dependency_dir = os.path.join(packages_dir, name)

    ver = u'st%s' % st_version
    plat = sublime.platform()
    arch = sublime.arch()

    return {
        'all': os.path.join(dependency_dir, 'all'),
        'ver': os.path.join(dependency_dir, ver),
        'plat': os.path.join(dependency_dir, u'%s_%s' % (ver, plat)),
        'arch': os.path.join(dependency_dir, u'%s_%s_%s' % (ver, plat, arch))
    }


def add_dependency(name, first=False):
    """
    Accepts a dependency name and automatically adds the appropriate path
    to sys.path, if the dependency has a path for the current platform and
    architecture.

    :param name:

```

--------------------------------

### Apply Syntax with Custom Function Rule

Source: https://facelessuser.github.io/ApplySyntax/usage

The `function` rule allows using custom Python functions defined in plugins to determine syntax application. It takes a `source` for the plugin and optional `args`. The plugin must define a `syntax_test` function returning True or False.

```json
{"function": {"source": "User.plugins.myplugin", "args": {"foo": "bar"}}}
```

```python
def syntax_test(file_path, foo):
    # Some test logic
    return False # True or False
```

--------------------------------

### Specify Syntax File Path - ApplySyntax Rule

Source: https://facelessuser.github.io/ApplySyntax/usage

This code demonstrates how to specify a syntax file path within an ApplySyntax rule. Paths are relative to the Sublime Text 'Packages' folder. The extension can be omitted, and ApplySyntax will default to '.sublime-syntax' then '.tmLanguage'.

```json
"syntax": "Rails/Language/Ruby Haml"
```

--------------------------------

### Search File Content for Specific Tokens

Source: https://facelessuser.github.io/ApplySyntax/usage

The `contains` rule searches the content of a file using regex for a specific token. It's recommended to pair this with other rules using `"match": "all"` to optimize performance and ensure reliable matches.

```json
{"contains": "<script [^>]*type=\"text\\/x-handlebars\[^>]*>"}
```

--------------------------------

### ApplySyntax General Settings - Add Extensions to Language Settings

Source: https://facelessuser.github.io/ApplySyntax/usage

Enable or disable the addition of defined extensions to language settings. Setting `add_exts_to_lang_settings` to `true` allows for this functionality, providing more control over syntax application based on file extensions. Refer to the 'Extensions' documentation for more details.

```json
{
    "add_exts_to_lang_settings": true,

}
```

--------------------------------

### Trim File Extension for Rule Matching

Source: https://facelessuser.github.io/ApplySyntax/usage

The `ext_trim` rule allows files to be re-evaluated without their last extension if they don't initially match a rule. This rule currently only contains a `file_path` pattern or can use `globmatch` patterns. This feature was added in version 4.0.

```json
"ext_trim": [{"file_path": ".*\\.py3\\.temp"}]
```

```json
"ext_trim": [{"globmatch": "**/*.py3.temp"}]
```

--------------------------------

### Match File Path with Regex

Source: https://facelessuser.github.io/ApplySyntax/usage

The `file_path` rule uses a regular expression to match against the complete file path. The pattern is always anchored to the beginning of the path. The `file_name` rule is accepted for backward compatibility and functions identically. Paths are normalized to use forward slashes on Windows.

```json
{"file_path": ".*\\.xml(\\.dist)?$"}
```

--------------------------------

### ApplySyntax General Settings - Re-Raise Exceptions

Source: https://facelessuser.github.io/ApplySyntax/usage

Configure whether exceptions encountered during function processing should be re-raised in the Sublime console. Setting `reraise_exceptions` to `true` provides user feedback for exceptions, primarily useful for developers writing functions. The default value is `false`.

```json
{
    "reraise_exceptions": false,

}
```

--------------------------------

### ApplySyntax General Settings - Debugging Level

Source: https://facelessuser.github.io/ApplySyntax/usage

Control the level of logging provided in the Sublime console for ApplySyntax. The `debug` setting can be set to `true` for standard feedback, `false` to disable logging, or `"verbose"` to receive more detailed information, which is useful for development and troubleshooting. The default value is `true`.

```json
{
    // Control level of logging in the console.
    // (true|false|"verbose")
    "debug": true,

}
```

--------------------------------

### Run Pytest Unit Tests - Command Line

Source: https://facelessuser.github.io/ApplySyntax/about/contributing

Executes the unit tests for the ApplySyntax plugin using 'pytest'. This command should be run from the root folder of the plugin.

```python
py.test .
```

--------------------------------

### Run Flake8 Linting - Command Line

Source: https://facelessuser.github.io/ApplySyntax/about/contributing

Performs linting on the entire ApplySyntax project using 'flake8'. This command checks for stylistic errors, potential bugs, and adherence to Python coding standards.

```python
flake8 .
```

--------------------------------

### Run ApplySyntax Validation Tests - Shell

Source: https://facelessuser.github.io/ApplySyntax/about/contributing

This script executes all validation tests for the ApplySyntax plugin on macOS or Linux/Unix systems. It requires the 'run_tests.sh' script to be executable and assumes all other dependencies are met.

```shell
chmod +x run_tests.sh
./run_tests.sh
```

--------------------------------

### Update Zsh Rules

Source: https://facelessuser.github.io/ApplySyntax/about/changelog

This update introduces new rules for Zsh syntax highlighting. No specific code is provided, but it implies modifications to the internal configuration or pattern definitions for Zsh files.

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.