-# Context Coloring [![Build Status](https://travis-ci.org/jacksonrayhamilton/context-coloring.png?branch=develop)](https://travis-ci.org/jacksonrayhamilton/context-coloring)
+# Context Coloring [![Build Status](https://travis-ci.org/jacksonrayhamilton/context-coloring.png?branch=master)](https://travis-ci.org/jacksonrayhamilton/context-coloring) [![Coverage Status](https://coveralls.io/repos/jacksonrayhamilton/context-coloring/badge.svg?branch=master)](https://coveralls.io/r/jacksonrayhamilton/context-coloring?branch=master)
<p align="center">
<img alt="Screenshot of JavaScript code highlighted by context." src="screenshot.png" title="Screenshot">
</p>
-Highlights code according to function context.
+Highlights code by scope. Top-level scopes are one color, second-level scopes
+are another color, and so on. Variables retain the color of the scope in which
+they are defined. A variable defined in an outer scope referenced by an inner
+scope is colored the same as the outer scope.
-- Code in the global scope is one color. Code in functions within the global
- scope is a different color, and code within such functions is another color,
- and so on.
-- Identifiers retain the color of the scope in which they are declared.
-
-Lexical scope information at-a-glance can assist a programmer in understanding
-the overall structure of a program. It can help to curb nasty bugs like name
-shadowing. A rainbow can indicate excessive complexity. State change within a
-closure is easily monitored.
-
-By default, Context Coloring still highlights comments and strings
-syntactically. It is still easy to differentiate code from non-code, and strings
-cannot be confused for variables.
-
-This coloring strategy is probably more useful than conventional syntax
-highlighting. Highlighting keywords can help one to detect spelling errors, but
-a [linter][] could also spot those errors, and if integrated with [flycheck][],
-an extra spot opens up in your editing toolbelt.
-
-Give context coloring a try; you may find that it *changes the way you write
-code*.
+By default, comments and strings are still highlighted syntactically.
## Features
-- Supported languages: JavaScript
-- Light and dark (customizable) color schemes.
-- Very fast for files under 1000 lines.
+- Light and dark customizable color schemes.
+- JavaScript support:
+ - Script, function and block scopes (and even `catch` block scopes).
+- Emacs Lisp support:
+ - `defun`, `lambda`, `let`, `let*`, `cond`, `condition-case`, `defadvice`,
+ `dolist`, `quote`, `backquote` and backquote splicing.
+ - Works in `eval-expression` too.
## Installation
-Requires Emacs 24+.
-
-JavaScript language support requires either [js2-mode][], or
-[Node.js 0.10+][node] and the [scopifier][] executable.
-
-```bash
-npm install -g scopifier
-```
-
-### ELPA
-
-- `M-x package-refresh-contents RET`
-- `M-x package-install RET context-coloring RET`
+Requires Emacs 24.3+. JavaScript language support requires
+[js2-mode](https://github.com/mooz/js2-mode).
-### Git
+To install, run the command `M-x package-install RET context-coloring RET`, and
+then add the following to your init file:
-- Clone this repository.
-
-```bash
-cd ~/.emacs.d/
-git clone https://github.com/jacksonrayhamilton/context-coloring.git
-```
-
-- Byte-compile the package for improved speed.
-
-```bash
-cd context-coloring/
-make compile
-```
+```lisp
+;; JavaScript:
+(add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode))
+(add-hook 'js2-mode-hook #'context-coloring-mode)
-- Add the following to your `~/.emacs` file:
+;; Emacs Lisp:
+(add-hook 'emacs-lisp-mode-hook #'context-coloring-mode)
-```lisp
-(add-to-list 'load-path "~/.emacs.d/context-coloring")
-(require 'context-coloring)
-(add-hook 'js2-mode-hook 'context-coloring-mode)
+;; eval-expression:
+(add-hook 'minibuffer-setup-hook #'context-coloring-mode)
```
-## Customizing
+## Color Schemes
-Built-in themes are accessible via `context-coloring-load-theme`. Available
-themes are: `monokai`, `solarized`, `tango` and `zenburn`.
-
-```lisp
-(require 'context-coloring)
-(context-coloring-load-theme 'zenburn)
-```
+You can define your own colors by customizing faces like
+`context-coloring-level-N-face`, where N is a number starting from 0.
-You can define your own themes, too:
+These are the colors used in the screenshot above:
```lisp
-(context-coloring-define-theme
+(custom-theme-set-faces
'zenburn
- :colors '("#DCDCCC"
- "#93E0E3"
- "#BFEBBF"
- "#F0DFAF"
- "#DFAF8F"
- "#CC9393"
- "#DC8CC3"
- "#94BFF3"
- "#9FC59F"
- "#D0BF8F"
- "#DCA3A3"))
-```
-
-## Extending
-
-To add support for a new language, write a "scopifier" for it, and define a new
-coloring dispatch strategy with `context-coloring-define-dispatch`. Then the
-plugin should handle the rest.
-
-A "scopifier" is a CLI program that reads a buffer's contents from stdin and
-writes a JSON array of numbers to stdout. Every three numbers in the array
-represent a range of color. For instance, if I fed the following string of
-JavaScript code to a scopifier,
-
-```js
-var a = function () {};
-```
-
-then the scopifier would produce the following array:
-
-```js
-[1,24,0,9,23,1]
+ '(context-coloring-level-0-face ((t :foreground "#dcdccc")))
+ '(context-coloring-level-1-face ((t :foreground "#93e0e3")))
+ '(context-coloring-level-2-face ((t :foreground "#bfebbf")))
+ '(context-coloring-level-3-face ((t :foreground "#f0dfaf")))
+ '(context-coloring-level-4-face ((t :foreground "#dfaf8f")))
+ '(context-coloring-level-5-face ((t :foreground "#cc9393")))
+ '(context-coloring-level-6-face ((t :foreground "#dc8cc3")))
+ '(context-coloring-level-7-face ((t :foreground "#94bff3")))
+ '(context-coloring-level-8-face ((t :foreground "#9fc59f")))
+ '(context-coloring-level-9-face ((t :foreground "#d0bf8f")))
+ '(context-coloring-level-10-face ((t :foreground "#dca3a3"))))
```
-Where, for every three numbers, the first number is a 1-indexed start [point][],
-the second number is an exclusive end point, and the third number is a scope
-level. The result of applying level 0 coloring to the range [1, 24) and then
-applying level 1 coloring to the range [9, 23) would result in the following
-coloring:
+[See here](https://gist.github.com/jacksonrayhamilton/6b89ca3b85182c490816) for
+some color schemes for popular custom themes.
-<p align="center">
- <img alt="Screenshot of ranges [1, 24) and [9, 23)." src="scopifier.png" title="Screenshot">
-</p>
-
-If there is an abstract syntax tree generator for your language, you can walk
-the syntax tree, find variables and scopes, and build their positions and levels
-into an array like the one above.
-
-For example, a Ruby scopifier might be defined and implemented like this:
-
-```lisp
-(context-coloring-define-dispatch
- 'ruby
- :modes '(ruby-mode)
- :executable "ruby"
- :command "/home/username/scopifier")
-```
-
-```ruby
-#!/usr/bin/env ruby
-def scopifier(code)
- # Parse code.
- # Return an array.
-end
-print scopifier ARGF.read
-```
+## Options
-When a `--version` argument is passed, a scopifier should print its version
-number and exit. For installable scopifiers, this allows context-coloring to
-check for updates as needed.
-
-[linter]: http://jshint.com/about/
-[flycheck]: http://www.flycheck.org/
-[zenburn]: http://github.com/bbatsov/zenburn-emacs
-[point]: http://www.gnu.org/software/emacs/manual/html_node/elisp/Point.html
-[js2-mode]: https://github.com/mooz/js2-mode
-[node]: http://nodejs.org/download/
-[scopifier]: https://github.com/jacksonrayhamilton/scopifier
-[load path]: https://www.gnu.org/software/emacs/manual/html_node/emacs/Lisp-Libraries.html
+- `context-coloring-syntactic-comments` (default: `t`): If non-nil, also color
+ comments using `font-lock`.
+- `context-coloring-syntactic-strings` (default: `t`): If non-nil, also color
+ strings using `font-lock`.
+- `context-coloring-javascript-block-scopes` (default: `nil`): If non-nil, also
+ color block scopes in the scope hierarchy in JavaScript.