Comby Versions Save

• Matches are now flushed to stdout per result (previously comby would possibly buffer more than one result).

• using the -tar option now outputs file paths in results (previously null)

• experimental: using the -omega option, whitespace between delimiters will be matched loosely instead of strictly. This gives more flexibility for pattern matching, g.g., a pattern like foo(bar) will match any of: foo( bar), foo(bar ) or something like

foo(
              bar
)

This only applies to whitespace immediately after an opening delimiter, and whitespace immediately preceding a closing delimiter.

Fixes JSON output of -json-lines which previously emitted double-escaped values like \\n instead of \n

• update language definitions (MATLAB, R)

• recognize Terraform file extension .tf for -lang flag (previously .hcl).

• additional property accesses .file aliased to file.path

• fixes behavior so that -newline-separated works with rewrite {...} rules

• custom metasyntax is now recognized for all terms inside rules

• custom metasyntax aliases are now applied to rules

Utility properties for holes. The following are introduced and recognized in rules and rewrite templates, and are substituted:

• Length. Substitute the length of a hole in rules and rewrite templates

:[hole].length

• String conversions. The following are recognized pattern that will substitute the value of :[hole] with the respective string processing in rewrite templates and rules

:[hole].lowercase
:[hole].UPPERCASE
:[hole].Capitalize
:[hole].uncapitalize
:[hole].UpperCamelCase
:[hole].lowerCamelCase
:[hole].UPPER_SNAKE_CASE
:[hole].lower_snake_case

• Filepaths. Substitute the file name, file path, or directory

:[hole].file.path
:[hole].file.name
:[hole].file.directory

• Simpler rule syntax modifications. Less strict parsing and more convenient/readable possibilities for rule syntax.

where :[x] == :[y],

where match :[x] {
|  :[y] -> :[z],
},

where match :[x] { :[y] -> :[z] }

where match :[x] { _ -> :[z] }

where match :[x] { :[_] -> :[z] }

where match :[x] { ~match-regex -> :[z] }

where match :[x] { :[~match-regex] -> :[z] }

where match :[x] { '"yep"\n' -> :[z] }

where match :[x] { `"yep"\n` -> :[z] }

where match :[x] { foo(:[x]) -> :[x] }

where rewrite :[x] { foo(:[x]) -> :[x] }

• Added .hcl language definition

• The experimental optional hole syntax is removed. Use regular expressions holes with optional modifiers ? instead.

• Changed -rg option to not emit an error when no matches/files are found to process.

• Support general metasyntax customization. See blog post and docs for more.

• Fixed an issue where substituting for regex syntax required repeating the pattern in the rewrite template. E.g., if a pattern like :[x~\w+] matched, it was necessary to specify :[x~\w+] in the rewrite template, instead of just :[x]. Now you can specify just :[x].

• It's now possible to define only match=... fields if you only want to implement a checker without rewrite=... in config files. This wasn't working correctly before (omitting rewrite would not work, or multiple match patterns would be ignored).

No functional changes. This is just a package split for comby the app, and comby-kernel, a minimal OCaml library.

• Allow specifying custom metasyntax definitions on the commandline via -custom-metasyntax #261

• Exposes Library API through comby.mli
• Support custom metasyntax definition (internal Library API)