TextMate 2.0

TextMate_r8926.tbz > http://api.cld.me/CZdZ/download/TextMate_r8926.tbz





**PLEASE DO NOT REPUBLISH THIS INFORMATION!**

We’re planning to release the alpha preview tomorrow.

Since there are a zillion things which can go wrong, I’m letting you
be the first batch of testers before inviting the masses.

You can download the preview here:
<http://updates.textmate.org/Application/TextMate_r8926.tbz>

We’re not asking for general feedback just “it didn’t launch at
all” and stuff like that which could possibly cause a hailstorm of
emails if this was posted to the blog.

A few caveats:

* This release will submit non-anonymous crash reports — you can
disable in Preferences (but we strongly encourage you to leave it
enabled).
* Several items in Preferences have no effect, one of them is “keep
bundles updated” (this is always enabled).
* Bundle editor is _very_ provisional and not how the final system will
work.
* Many settings you toggle via the menus are not preserved, some are
even lost when you switch tab. Generally though these things can be set
via `.tm_properties`.

Superficial release notes follows.

The linked articles will follow later.

* Multiple carets / discontinuous selection

        The easiest way to get multiple carets is by doing a left or right
movement command (like arrow left/right) with a column selection. You
can also ⌘-click to place new carets or use _Edit → Find All_
(⌥⌘F). [Thorough post about the new possibilities
here][multiple_carets].

* Snippets

        New syntax for pop-up menus: `${1|first,second,…,last|}`. In a Git
commit message try `fixup⇥` to get a pop-up of your last 10 commit
messages (for a `fixup!`-commit) or between `@interface`…`@end` in
Objective-C you can try `prop⇥` to get a `@property`-declaration with
pop-up for its access type.

        Snippets can be nested, a frequent request but it does cause a few
false firings of snippets which we haven’t yet found a good solution
for.

* Movement / Selection

        Text is classified into units which you can change with the
`characterClass` (scope) setting. For example a C string with `%1$ld\n`
has only two units (`%1$ld` and `\n`) for the purpose of selection
(_Select → Word_ or double click), word movement (⌥⇠/⌥⇢), and
other functions that rely on character types.

        TextMate 1.x has _Select → Block_ (⇧⌘B) where a block is found
using scope-defined paired characters such as braces, brackets, etc. In
2.0 you can move to begin/end of such block with ⌃⇡/⌃⇣ and the
paired characters can be strings (planned to be patterns).

        Whenever you select a unit (like anything in the _Edit → Select_
submenu) the selection is “unanchored”, meaning it can be extended
to either the left or right side. A minor thing but I find it
surprisingly useful, e.g. to select `foo(bar‸)` we first select the
parenthesis with ⇧⌘B and then extend left by one unit with
⌥⇧⇠, previously you couldn’t be sure the last step would extend
or simply move the selection end point.

* Themes

        There now is the ability to change font and font size per scope. So
you’ll (by default) see that headings in markup are shown with a
larger (non-fixed width) font.

        You can also change soft wrap on a per-line basis, so soft wrap is e.g.
disabled (by default) for diffs embedded in Git commit messages, raw
(code) blocks embedded in markup, and enabled for line comments in
source.

        Soft wrap can be indented. This is also based on scoped settings so
list items in markup are indented differently than line comments in
source.

        [More info in this post][layout].

* Foldings

        Foldings have been taken out of grammars and are now per-line (via
scoped settings). In addition there are two new patterns to allow
folding indented blocks. See the [layout post][layout] for details.

* Indent

        TextMate is more aggressive about doing indent corrections. This works
great when the patterns are well-calibrated but can be disabled with the
`disableIndentCorrections` scope-setting. This setting also change the
behavior of re-indented paste to a heuristic that works much better with
Python (for which indent corrections are disabled by default).

* Folder specific settings

        Variables and some settings can be set on a folder / file-type basis.
[More info in this post][tm_properties].

* Project drawer

        The project drawer has been replaced with a file browser sidebar. This
file browser has most Finder functions (labels, duplicate, etc.) and
does SCM-badging, presently only for Subversion, Git, and Mercurial. In
addition it has support for running commands (although somewhat
proof-of-concept ATM) and can also do custom data sources, the API is
not yet public but an SCM Status data source is included (the smart
folder icon) which show SCM status for the current project. This data
source works great together with the various SCM bundles.

* Buffer completion

        This has been improved to work with the existing word suffix (in
addition to prefix), use the new character class system, etc. [More
details in this article][completion].

* Shell invocation

        _Preferences → Terminal_ allows you to install `mate` which has a few
new options and work when called as `sudo mate`. In addition you’ll
find `rmate` which is a ruby implementation that you can use on a server
over ssh. [See this article for more info][mate_and_rmate].

* Search in project / folder

        Revamped the old “Find in Folder” and merged it with the regular
find dialog. It’s now asynchronous, a lot faster, and more flexible.
[See this article for more info][find].

* Format strings

        Format strings are ubiquitous in TextMate 2. Even scopes in grammars
are format strings (allowing you to capture document content for use in
scopes) and format strings are more powerful than the 1.x variant. [See
this article for more info][format_strings].

* Scopes

        Scopes now contain info beyond document context. For example the
`attr.scm` scopes give info about the current file’s SCM status,
allowing using same key equivalent for different SCM systems.

        The `dyn` scopes give info such as “is there a selection” (allowing
to change key bindings only when there is or isn’t a selection), an
example of this is overloading `{` to “wrap selection” (nicely), but
leave the key alone when there is no selection. Another use-case could
be to change tab to shift the text right (indent) only when there is a
selection (common user request that I don’t plan to make native
behavior).

        You can also add your own stuff to the scope via the file and folder
specific settings which allows e.g. adding `attr.test` to your unit
tests and overload ⌘R for that scope or have certain snippets only
fire in that scope (e.g. we have a `main⇥` snippet for C which inserts
the venerable main function — makes sense to overload this for (C)
unit tests, which generally would be regular C files).

* Scope selectors

        The caret is actually between two scopes, the left and right characters
scope. In 2.0 we finally allow you to explicitly target either side (or
both), making the firing of certain overloads more correct. There are
also a few other new things related to scope selectors, but a lot of it
is still only implemented in the parser, so will delay the thorough
explanation of this.

* Commands

        Commands can require other bundles which allow them to reference
support files in the required bundle. They can also declare which shell
commands they need which means better error handling and also having
TextMate try to find the required commands. Failing commands result in
more graceful error dialogs. The output options for a command has been
split into location and format. Commands can run without a document.

* Grammars

        Grammars can be injected into existing scopes, for example there are
now grammars for marking URLs, `TODO`, and similar which are injected
into comments and other appropriate places.

        Various other things related to parsing which require its own post.

* Semantic classes

        Bundle items can now be assigned a semantic class. This allows us to
query for e.g. `action.build || action.run` (for current scope) to find
an appropriate build command (with a run command as fallback). The
advantage of this is manyfold: ability to do tool bars, palettes, and
unified key bindings, for example we have a single _proxy item_ bound to
⌘Y which does a query for `action.scm` finding all the SCM actions
relevant for the current scope (remember scope now include SCM info,
making it pick the proper SCM system).

        Proxy items are a new construct but still at the proof-of-concept
level, so more about this later.

        TextMate itself will also do queries at various times, for example when
opening a file it queries for import commands, where we include several
to decompile AppleScript, pretty-print binary property lists, and
similar. It also uses this system on save, so by default we now make new
scripts with a shebang executable after save.

        Like proxy items, this system is in its infancy.

* Managed bundles

        When you open a file type for which you have no bundle, you’ll be
asked to install one (if TextMate knows of one). Bundles are
automatically kept up to date and you can see installed bundles (and
install more) in _Preferences → Bundles_.

* Session restore

        TextMate restores the full session which includes unsaved changes
incase of abnormal exit.
_______________________________________________
textmate-dev mailing list
textmate-dev@...
http://lists.macromates.com/listinfo/textmate-dev