forks
/
dfmt
mirror of https://github.com/dlang-community/dfmt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Editorconfig support

This commit is contained in:
Hackerpilot 2015-04-19 21:51:37 -07:00
parent 854569fded
commit d0e255e62d
8 changed files with 287 additions and 312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
.editorconfig
View File

@ -1,12 +1,21 @@
[*.d]
end_of_line = lf
insert_final_newline = true
indent_size = 4
tab_width = 8
trim_trailing_whitespace = true
indent_style = space
[*] [*]
trim_trailing_whitespace = true trim_trailing_whitespace = true
end_of_line = lf end_of_line = lf
insert_final_newline = true insert_final_newline = true
[*.d]
dfmt_align_switch_statements = true
dfmt_brace_style = otbs
dfmt_outdent_attributes = true
dfmt_outdent_labels = true
dfmt_soft_max_line_length = 80
dfmt_space_after_cast = true
dfmt_space_after_keywords = true
dfmt_split_operator_at_line_end = false
end_of_line = lf
indent_size = 8
indent_style = tab
insert_final_newline = true
max_line_length = 120
tab_width = 8
trim_trailing_whitespace = true

26
README.md
View File

@ -25,6 +25,32 @@ file instead, and output will be written to ```stdout```.
placing opening braces on their own line. This is the default. placing opening braces on their own line. This is the default.
* ```--tabs```: Use tabs for indentation instead of spaces. * ```--tabs```: Use tabs for indentation instead of spaces.
## Configuration
**dfmt** uses [EditorConfig](http://editorconfig.org/) configuration files.
**dfmt**-specific properties are prefixed with *dfmt_*.
### Standard EditorConfig properties
Property Name | Allowed Values | Default Value | Description
--------------|----------------|---------------|------------
end_of_line | | TODO | Not yet supported
insert_final_newline | | `true` | Not supported. **dfmt** always inserts a final newline
charset | | `UTf-8` | Not supported. **dfmt** only works correctly on UTF-8.
indent_style | `tab`, `space` | `space` | Supported
indent_size | positive integers | `4` | Supported
tab_width | positive integers | `8` | Supported
trim_trailing_whitespace | | `true` | Not supported. **dfmt** does not emit trailing whitespace
max_line_length | positive integers | `120` | Supported
### dfmt-specific properties
Property Name | Allowed Values | Default Value | Description
--------------|----------------|---------------|------------
dfmt_brace_style | `allman`, `otbs`, or `stroustrup` | https://en.wikipedia.org/wiki/Brace_style
dfmt_soft_max_line_length | positive integers | The formatting process will usually keep lines below this length, but they may be up to max_line_length columns long.
dfmt_outdent_labels (Not yet implemented) | `true`, `false` | Decrease the indentation of labels
dfmt_align_switch_statements (Not yet implemented) | `true`, `false` | Align labels, cases, and defaults with their enclosing switch
dfmt_outdent_attributes (Not yet implemented) | `true`, `false` | Decrease the indentation level of attributes
dfmt_split_operator_at_line_end (Not yet implemented) | `true`, `false` | Place operators on the end of the previous line when splitting lines
dfmt_space_after_cast (Not yet implemented) | `true`, `false` | Insert space after the closing paren of a `cast` expression
dfmt_space_after_keywords (Not yet implemented) | `true`, `false` | Insert space after `if`, `while`, `foreach`, etc, and before the `(`
## Terminology ## Terminology
* Braces - `{` and `}` * Braces - `{` and `}`
* Brackets - `[` and `]` * Brackets - `[` and `]`

110
src/dfmt/config.d
View File

@ -5,9 +5,12 @@
module dfmt.config; module dfmt.config;
import dfmt.editorconfig;
/// Brace styles /// Brace styles
enum BraceStyle enum BraceStyle
{ {
unspecified,
/// $(LINK https://en.wikipedia.org/wiki/Indent_style#Allman_style) /// $(LINK https://en.wikipedia.org/wiki/Indent_style#Allman_style)
allman, allman,
/// $(LINK https://en.wikipedia.org/wiki/Indent_style#Variant:_1TBS) /// $(LINK https://en.wikipedia.org/wiki/Indent_style#Variant:_1TBS)
@ -16,76 +19,42 @@ enum BraceStyle
stroustrup stroustrup
} }
/// Newline styles
enum Newlines
{
/// Old Mac
cr,
/// UNIX, Linux, BSD, New Mac, iOS, Android, etc...
lf,
/// Windows
crlf
}
template getHelp(alias S)
{
enum getHelp = __traits(getAttributes, S)[0].text;
}
/// Configuration options for formatting /// Configuration options for formatting
struct Config struct Config
{ {
/// ///
@Help("Number of spaces used for indentation") OptionalBoolean dfmt_align_switch_statements = OptionalBoolean.t;
uint indentSize = 4;
/// ///
@Help("Use tabs or spaces") BraceStyle dfmt_brace_style = BraceStyle.allman;
bool useTabs = false;
/// ///
@Help("Size of a tab character") OptionalBoolean dfmt_outdent_attributes = OptionalBoolean.t;
uint tabSize = 4;
/// ///
@Help("Soft line wrap limit") OptionalBoolean dfmt_outdent_labels = OptionalBoolean.t;
uint columnSoftLimit = 80;
/// ///
@Help("Hard line wrap limit") int dfmt_soft_max_line_length = 80;
uint columnHardLimit = 120;
/// ///
@Help("Brace style can be 'otbs', 'allman', or 'stroustrup'") OptionalBoolean dfmt_space_after_cast = OptionalBoolean.t;
BraceStyle braceStyle = BraceStyle.allman;
/// ///
@Help("Align labels, cases, and defaults with their enclosing switch") OptionalBoolean dfmt_space_after_keywords = OptionalBoolean.t;
bool alignSwitchStatements = true;
/// ///
@Help("Decrease the indentation of labels") OptionalBoolean dfmt_split_operator_at_line_end = OptionalBoolean.f;
bool outdentLabels = true;
/// mixin StandardEditorConfigFields;
@Help("Decrease the indentation level of attributes")
bool outdentAttributes = true;
///
@Help("Place operators on the end of the previous line when splitting lines")
bool splitOperatorAtEnd = false;
/// /**
@Help("Insert spaces after the closing paren of a cast expression") * Initializes the standard EditorConfig properties with default values that
bool spaceAfterCast = true; * make sense for D code.
*/
/// void initializeWithDefaults()
@Help("Newline style can be 'cr', 'lf', or 'crlf'") {
Newlines newlineType; pattern = "*.d";
end_of_line = EOL.lf;
/// indent_style = IndentStyle.space;
@Help("Insert spaces after 'if', 'while', 'foreach', etc, and before the '('") indent_size = 4;
bool spaceAfterBlockKeywords; tab_width = 4;
max_line_length = 120;
}
/** /**
* Returns: * Returns:
@ -95,7 +64,7 @@ struct Config
{ {
import std.stdio : stderr; import std.stdio : stderr;
if (columnSoftLimit > columnHardLimit) if (dfmt_soft_max_line_length > max_line_length)
{ {
stderr.writeln("Column hard limit must be greater than or equal to column soft limit"); stderr.writeln("Column hard limit must be greater than or equal to column soft limit");
return false; return false;
@ -103,30 +72,3 @@ struct Config
return true; return true;
} }
} }
/**
* Reads arguments from a file at the given path into the given string array
*/
void readConfig(string path, ref string[] args)
{
import std.stdio : File;
import std.file : exists;
import std.array : empty, RefAppender;
if (!exists(path))
return;
auto f = File(path);
auto app = RefAppender!(string[])(&args);
import std.algorithm : map, copy, sort, uniq, filter;
foreach (a; f.byLine().filter!(a => !a.empty).map!(a => a.idup))
app.put(a);
app.data[1 .. $].sort();
}
private struct Help
{
string text;
}

242
src/dfmt/editorconfig.d
View File

@ -7,63 +7,63 @@ private auto commentRe = ctRegex!(`^\s*[#;].*$`);
enum OptionalBoolean : ubyte enum OptionalBoolean : ubyte
{ {
unspecified = 3, unspecified = 3,
t = 1, t = 1,
f = 0 f = 0
} }
enum IndentStyle : ubyte enum IndentStyle : ubyte
{ {
unspecified, unspecified,
tab, tab,
space space
} }
enum EOL : ubyte enum EOL : ubyte
{ {
unspecified, unspecified,
lf, lf,
cr, cr,
crlf crlf
} }
mixin template StandardEditorConfigFields() mixin template StandardEditorConfigFields()
{ {
string pattern; string pattern;
OptionalBoolean root; OptionalBoolean root;
EOL end_of_line; EOL end_of_line;
OptionalBoolean insert_final_newline; OptionalBoolean insert_final_newline;
string charset; string charset;
IndentStyle indent_style; IndentStyle indent_style;
int indent_size = -1; int indent_size = -1;
int tab_width = -1; int tab_width = -1;
OptionalBoolean trim_trailing_whitespace; OptionalBoolean trim_trailing_whitespace;
int max_line_length = -1; int max_line_length = -1;
void merge(ref const typeof(this) other, const string fileName) void merge(ref const typeof(this) other, const string fileName)
{ {
import std.path : globMatch; import std.path : globMatch;
import std.traits : FieldNameTuple; import std.traits : FieldNameTuple;
if (other.pattern is null || !fileName.globMatch(other.pattern)) if (other.pattern is null || !fileName.globMatch(other.pattern))
return; return;
foreach (N; FieldNameTuple!(typeof(this))) foreach (N; FieldNameTuple!(typeof(this)))
{ {
alias T = typeof(mixin(N)); alias T = typeof(mixin(N));
const otherN = mixin("other." ~ N); const otherN = mixin("other." ~ N);
auto thisN = &mixin("this." ~ N); auto thisN = &mixin("this." ~ N);
static if (N == "pattern") static if (N == "pattern")
continue; continue;
else static if (is (T == enum)) else static if (is (T == enum))
*thisN = otherN != T.unspecified ? otherN : *thisN; *thisN = otherN != T.unspecified ? otherN : *thisN;
else static if (is (T == int)) else static if (is (T == int))
*thisN = otherN != -1 ? otherN : *thisN; *thisN = otherN != -1 ? otherN : *thisN;
else static if (is (T == string)) else static if (is (T == string))
*thisN = otherN !is null ? otherN : *thisN; *thisN = otherN !is null ? otherN : *thisN;
else else
static assert(false); static assert(false);
} }
} }
} }
/** /**
@ -74,94 +74,84 @@ mixin template StandardEditorConfigFields()
*/ */
EC getConfigFor(EC)(string path) EC getConfigFor(EC)(string path)
{ {
import std.stdio : File; import std.stdio : File;
import std.regex : regex, match; import std.regex : regex, match;
import std.path : globMatch, dirName, baseName, pathSplitter, buildPath; import std.path : globMatch, dirName, baseName, pathSplitter, buildPath;
import std.algorithm : reverse, map, filter, each; import std.algorithm : reverse, map, filter, each;
import std.array : array; import std.array : array;
EC result; EC result;
EC[][] configs; EC[][] configs;
string dir = dirName(path); string dir = dirName(path);
immutable string fileName = baseName(path); immutable string fileName = baseName(path);
string[] pathParts = cast(string[]) pathSplitter(dir).array(); string[] pathParts = cast(string[]) pathSplitter(dir).array();
for (size_t i = pathParts.length; i > 1; i--) for (size_t i = pathParts.length; i > 1; i--)
{ {
EC[] sections = parseConfig!EC(buildPath(pathParts[0 .. i])); EC[] sections = parseConfig!EC(buildPath(pathParts[0 .. i]));
if (sections.length) if (sections.length)
configs ~= sections; configs ~= sections;
if (!sections.map!(a => a.root).filter!(a => a == OptionalBoolean.t).empty) if (!sections.map!(a => a.root).filter!(a => a == OptionalBoolean.t).empty)
break; break;
} }
reverse(configs); reverse(configs);
configs.each!(a => a.each!(b => result.merge(b, fileName)))(); configs.each!(a => a.each!(b => result.merge(b, fileName)))();
return result; return result;
} }
private EC[] parseConfig(EC)(string dir) private EC[] parseConfig(EC)(string dir)
{ {
import std.stdio : File; import std.stdio : File;
import std.file : exists; import std.file : exists;
import std.path : buildPath; import std.path : buildPath;
import std.regex : matchAll; import std.regex : matchAll;
import std.traits : FieldNameTuple; import std.traits : FieldNameTuple;
import std.conv : to; import std.conv : to;
import std.uni : toLower; import std.uni : toLower;
EC section; EC section;
EC[] sections; EC[] sections;
immutable string path = buildPath(dir, ".editorconfig"); immutable string path = buildPath(dir, ".editorconfig");
if (!exists(path)) if (!exists(path))
return sections; return sections;
File f = File(path); File f = File(path);
foreach (line; f.byLineCopy()) foreach (line; f.byLineCopy())
{ {
auto headerMatch = line.matchAll(headerRe); auto headerMatch = line.matchAll(headerRe);
if (headerMatch) if (headerMatch)
{ {
sections ~= section; sections ~= section;
section = EC.init; section = EC.init;
auto c = headerMatch.captures; auto c = headerMatch.captures;
c.popFront(); c.popFront();
section.pattern = c.front(); section.pattern = c.front();
} }
else else
{ {
auto propertyMatch = line.matchAll(propertyRe); auto propertyMatch = line.matchAll(propertyRe);
if (propertyMatch) if (propertyMatch)
{ {
auto c = propertyMatch.captures; auto c = propertyMatch.captures;
c.popFront(); c.popFront();
immutable string propertyName = c.front(); immutable string propertyName = c.front();
c.popFront(); c.popFront();
immutable string propertyValue = toLower(c.front()); immutable string propertyValue = toLower(c.front());
foreach (F; FieldNameTuple!EC) foreach (F; FieldNameTuple!EC)
{ {
enum configDot = "section." ~ F; enum configDot = "section." ~ F;
alias FieldType = typeof(mixin(configDot)); alias FieldType = typeof(mixin(configDot));
if (F == propertyName) if (F == propertyName)
{ {
static if (is(FieldType == OptionalBoolean)) static if (is(FieldType == OptionalBoolean))
mixin(configDot) = propertyValue == "true" ? OptionalBoolean.t mixin(configDot) = propertyValue == "true" ? OptionalBoolean.t
: OptionalBoolean.f; : OptionalBoolean.f;
else else
mixin(configDot) = to!(FieldType)(propertyValue); mixin(configDot) = to!(FieldType)(propertyValue);
} }
} }
} }
} }
} }
sections ~= section; sections ~= section;
return sections; return sections;
}
version (editorconfig_main) void main()
{
import std.stdio : writeln;
static struct EditorConfig { mixin StandardEditorConfigFields; }
auto c = getConfigFor!EditorConfig("/home/brian/src/aias/src/dummy.d");
writeln(c);
} }

25
src/dfmt/formatter.d
View File

@ -321,7 +321,7 @@ private:
} }
assert(lengthOfNextChunk > 0); assert(lengthOfNextChunk > 0);
writeToken(); writeToken();
if (currentLineLength + 1 + lengthOfNextChunk >= config.columnSoftLimit) if (currentLineLength + 1 + lengthOfNextChunk >= config.dfmt_soft_max_line_length)
{ {
pushWrapIndent(tok!","); pushWrapIndent(tok!",");
newline(); newline();
@ -359,7 +359,7 @@ private:
} }
else if (!currentIs(tok!")") && !currentIs(tok!"]") else if (!currentIs(tok!")") && !currentIs(tok!"]")
&& (linebreakHints.canFindIndex(index - 1) || (linebreakHints.length == 0 && (linebreakHints.canFindIndex(index - 1) || (linebreakHints.length == 0
&& currentLineLength > config.columnHardLimit))) && currentLineLength > config.max_line_length)))
{ {
pushWrapIndent(p); pushWrapIndent(p);
newline(); newline();
@ -455,7 +455,7 @@ private:
{ {
if ((parenDepth > 0 && sBraceDepth == 0) || (sBraceDepth > 0 && niBraceDepth > 0)) if ((parenDepth > 0 && sBraceDepth == 0) || (sBraceDepth > 0 && niBraceDepth > 0))
{ {
if (currentLineLength > config.columnSoftLimit) if (currentLineLength > config.dfmt_soft_max_line_length)
{ {
writeToken(); writeToken();
pushWrapIndent(tok!";"); pushWrapIndent(tok!";");
@ -488,7 +488,7 @@ private:
auto e = expressionEndIndex(index); auto e = expressionEndIndex(index);
immutable int l = currentLineLength + tokens[index .. e].map!(a => tokenLength(a)).sum(); immutable int l = currentLineLength + tokens[index .. e].map!(a => tokenLength(a)).sum();
writeToken(); writeToken();
if (l > config.columnSoftLimit) if (l > config.dfmt_soft_max_line_length)
{ {
indents.push(tok!"{"); indents.push(tok!"{");
newline(); newline();
@ -504,7 +504,7 @@ private:
auto e = expressionEndIndex(index); auto e = expressionEndIndex(index);
immutable int l = currentLineLength + tokens[index .. e].map!(a => tokenLength(a)).sum(); immutable int l = currentLineLength + tokens[index .. e].map!(a => tokenLength(a)).sum();
writeToken(); writeToken();
if (l > config.columnSoftLimit) if (l > config.dfmt_soft_max_line_length)
{ {
indents.push(tok!"{"); indents.push(tok!"{");
newline(); newline();
@ -520,7 +520,7 @@ private:
if (!justAddedExtraNewline && !peekBackIsOneOf(false, tok!"{", if (!justAddedExtraNewline && !peekBackIsOneOf(false, tok!"{",
tok!"}", tok!";", tok!";")) tok!"}", tok!";", tok!";"))
{ {
if (config.braceStyle != BraceStyle.allman) if (config.dfmt_brace_style != BraceStyle.allman)
{ {
if (!astInformation.structInitStartLocations.canFindIndex(tokens[index].index) if (!astInformation.structInitStartLocations.canFindIndex(tokens[index].index)
&& !astInformation.funLitStartLocations.canFindIndex( && !astInformation.funLitStartLocations.canFindIndex(
@ -583,7 +583,7 @@ private:
currentLineLength = 0; currentLineLength = 0;
justAddedExtraNewline = true; justAddedExtraNewline = true;
} }
if (config.braceStyle == BraceStyle.otbs && currentIs(tok!"else")) if (config.dfmt_brace_style == BraceStyle.otbs && currentIs(tok!"else"))
write(" "); write(" ");
if (!peekIs(tok!",") && !peekIs(tok!")") && !peekIs(tok!";")) if (!peekIs(tok!",") && !peekIs(tok!")") && !peekIs(tok!";"))
{ {
@ -788,7 +788,7 @@ private:
break; break;
case tok!".": case tok!".":
if (linebreakHints.canFind(index) || (linebreakHints.length == 0 if (linebreakHints.canFind(index) || (linebreakHints.length == 0
&& currentLineLength + nextTokenLength() > config.columnHardLimit)) && currentLineLength + nextTokenLength() > config.max_line_length))
{ {
pushWrapIndent(); pushWrapIndent();
newline(); newline();
@ -869,7 +869,7 @@ private:
newline(); newline();
} }
else if (!peekIs(tok!"}") && (linebreakHints.canFind(index) else if (!peekIs(tok!"}") && (linebreakHints.canFind(index)
|| (linebreakHints.length == 0 && currentLineLength > config.columnSoftLimit))) || (linebreakHints.length == 0 && currentLineLength > config.dfmt_soft_max_line_length)))
{ {
writeToken(); writeToken();
pushWrapIndent(tok!","); pushWrapIndent(tok!",");
@ -1072,15 +1072,16 @@ private:
void indent() void indent()
{ {
if (config.useTabs) import dfmt.editorconfig : IndentStyle;
if (config.indent_style == IndentStyle.tab)
foreach (i; 0 .. indentLevel) foreach (i; 0 .. indentLevel)
{ {
currentLineLength += config.tabSize; currentLineLength += config.tab_width;
output.put("\t"); output.put("\t");
} }
else else
foreach (i; 0 .. indentLevel) foreach (i; 0 .. indentLevel)
foreach (j; 0 .. config.indentSize) foreach (j; 0 .. config.indent_size)
{ {
output.put(" "); output.put(" ");
currentLineLength++; currentLineLength++;

155
src/dfmt/main.d
View File

@ -12,93 +12,57 @@ else
{ {
import std.array : front, popFront; import std.array : front, popFront;
import std.stdio : stdout, stdin, stderr, writeln, File; import std.stdio : stdout, stdin, stderr, writeln, File;
import dfmt.config : Config, getHelp, readConfig; import dfmt.config : Config;
import dfmt.formatter : format; import dfmt.formatter : format;
import std.path : buildPath, expandTilde; import std.path : buildPath, expandTilde;
import dfmt.editorconfig : getConfigFor;
import std.getopt : getopt;
int main(string[] args) int main(string[] args)
{ {
bool inplace = false; bool inplace = false;
Config optConfig;
optConfig.pattern = "*.d";
bool showHelp;
getopt(args,
"align_switch_statements", &optConfig.dfmt_align_switch_statements,
"brace_style", &optConfig.dfmt_brace_style,
"end_of_line", &optConfig.end_of_line,
"help|h", &showHelp,
"indent_size", &optConfig.indent_size,
"indent_style|t", &optConfig.indent_style,
"inplace", &inplace,
"max_line_length", &optConfig.max_line_length,
"max_line_length", &optConfig.max_line_length,
"outdent_attributes", &optConfig.dfmt_outdent_attributes,
"outdent_labels", &optConfig.dfmt_outdent_labels,
"space_after_cast", &optConfig.dfmt_space_after_cast,
"split_operator_at_line_end", &optConfig.dfmt_split_operator_at_line_end,
"tab_width", &optConfig.tab_width);
if (showHelp)
{
printHelp();
return 0;
}
args.popFront();
immutable bool readFromStdin = args.length == 0;
immutable string filePath = createFilePath(readFromStdin, readFromStdin ? null : args[0]);
Config config; Config config;
string configPath = expandTilde("~/.config/dfmt/dfmtrc"); config.initializeWithDefaults();
readConfig(configPath, args); Config fileConfig = getConfigFor!Config(filePath);
fileConfig.pattern = "*.d";
static if (__VERSION__ >= 2067) config.merge(fileConfig, filePath);
{ config.merge(optConfig, filePath);
import std.getopt : getopt, defaultGetoptPrinter;
auto getOptResult = getopt(args,
"inplace", "Modify files in-place", &inplace,
"tabs|t", getHelp!(Config.useTabs), &config.useTabs,
"braces", getHelp!(Config.braceStyle), &config.braceStyle,
"colSoft", getHelp!(Config.columnSoftLimit), &config.columnSoftLimit,
"colHard", getHelp!(Config.columnHardLimit), &config.columnHardLimit,
"tabSize", getHelp!(Config.tabSize), &config.tabSize,
"indentSize", getHelp!(Config.indentSize), &config.indentSize,
"alignSwitchCases", getHelp!(Config.alignSwitchStatements), &config.alignSwitchStatements,
"outdentLabels", getHelp!(Config.outdentLabels), &config.outdentLabels,
"outdentAttributes", getHelp!(Config.outdentAttributes), &config.outdentAttributes,
"splitOperatorAtEnd", getHelp!(Config.splitOperatorAtEnd), &config.splitOperatorAtEnd,
"spaceAfterCast", getHelp!(Config.spaceAfterCast), &config.spaceAfterCast,
"newlineType", getHelp!(Config.newlineType), &config.newlineType,
"spaceAfterBlockKeywords", getHelp!(Config.spaceAfterBlockKeywords), &config.spaceAfterBlockKeywords);
if (getOptResult.helpWanted)
{
defaultGetoptPrinter("dfmt 0.3.0-dev\n\nOptions:", getOptResult.options);
return 0;
}
}
else
{
import std.getopt : getopt;
bool showHelp;
getopt(args,
"help|h", &showHelp,
"inplace", &inplace,
"tabs|t", &config.useTabs,
"braces", &config.braceStyle,
"colSoft", &config.columnSoftLimit,
"colHard", &config.columnHardLimit,
"tabSize", &config.tabSize,
"indentSize", &config.indentSize,
"alignSwitchCases", &config.alignSwitchStatements,
"outdentLabels", &config.outdentLabels,
"outdentAttributes", &config.outdentAttributes,
"splitOperatorAtEnd", &config.splitOperatorAtEnd,
"spaceAfterCast", &config.spaceAfterCast,
"newlineType", &config.newlineType);
if (showHelp)
{
writeln(`dfmt 0.3.0-dev
Options:
--help | -h Print this help message
--inplace Edit files in place
--tabs | -t Use tabs instead of spaces
--braces Brace style can be 'otbs', 'allman', or 'stroustrup'
--colSoft Column soft limit
--colHard Column hard limit
--tabSize Size of tabs
--indentSize Number of spaces used for indentation
--alignSwitchCases Align cases, defaults, and labels with enclosing
switches
--outdentLabels Outdent labels
--outdentAttributes Outdent attribute declarations
--splitOperatorAtEnd Place operators at the end of the previous line when
wrapping
--spaceAfterCast Insert spaces after cast expressions
--newlineType Newline type can be 'cr', 'lf', or 'crlf'`);
return 0;
}
}
if (!config.isValid()) if (!config.isValid())
return 1; return 1;
File output = stdout; File output = stdout;
ubyte[] buffer; ubyte[] buffer;
args.popFront();
if (args.length == 0) if (readFromStdin)
{ {
ubyte[4096] inputBuffer; ubyte[4096] inputBuffer;
ubyte[] b; ubyte[] b;
@ -142,3 +106,46 @@ Options:
return 0; return 0;
} }
} }
private void printHelp()
{
writeln(`dfmt 0.3.0-dev
Options:
--help | -h Print this help message
--inplace Edit files in place
Formatting Options:
--align_switch_statements
--brace_style
--end_of_line
--help|h
--indent_size
--indent_style|t
--inplace
--max_line_length
--max_line_length
--outdent_attributes
--outdent_labels
--space_after_cast
--split_operator_at_line_end`);
}
private string createFilePath(bool readFromStdin, string fileName)
//out (result)
//{
// stderr.writeln(__FUNCTION__, ": ", result);
//}
//body
{
import std.file : getcwd;
import std.path : isRooted;
immutable string cwd = getcwd();
if (readFromStdin)
return buildPath(cwd, "dummy.d");
if (isRooted(fileName))
return fileName;
else
return buildPath(cwd, fileName);
}

14
src/dfmt/wrapping.d
View File

@ -18,7 +18,7 @@ struct State
import core.bitop : popcnt, bsf; import core.bitop : popcnt, bsf;
import std.algorithm : min, map, sum; import std.algorithm : min, map, sum;
immutable int remainingCharsMultiplier = config.columnHardLimit - config.columnSoftLimit; immutable int remainingCharsMultiplier = config.max_line_length - config.dfmt_soft_max_line_length;
immutable int newlinePenalty = remainingCharsMultiplier * 20; immutable int newlinePenalty = remainingCharsMultiplier * 20;
this.breaks = breaks; this.breaks = breaks;
@ -29,9 +29,9 @@ struct State
if (breaks == 0) if (breaks == 0)
{ {
immutable int l = currentLineLength + tokens.map!(a => tokenLength(a)).sum(); immutable int l = currentLineLength + tokens.map!(a => tokenLength(a)).sum();
if (l > config.columnSoftLimit) if (l > config.dfmt_soft_max_line_length)
{ {
immutable int longPenalty = (l - config.columnSoftLimit) * remainingCharsMultiplier; immutable int longPenalty = (l - config.dfmt_soft_max_line_length) * remainingCharsMultiplier;
this._cost += longPenalty; this._cost += longPenalty;
this._solved = longPenalty < newlinePenalty; this._solved = longPenalty < newlinePenalty;
} }
@ -58,18 +58,18 @@ struct State
immutable uint bits = b ? 0 : bsf(k); immutable uint bits = b ? 0 : bsf(k);
immutable size_t j = min(i + bits + 1, tokens.length); immutable size_t j = min(i + bits + 1, tokens.length);
ll += tokens[i .. j].map!(a => tokenLength(a)).sum(); ll += tokens[i .. j].map!(a => tokenLength(a)).sum();
if (ll > config.columnSoftLimit) if (ll > config.dfmt_soft_max_line_length)
{ {
immutable int longPenalty = (ll - config.columnSoftLimit) * remainingCharsMultiplier; immutable int longPenalty = (ll - config.dfmt_soft_max_line_length) * remainingCharsMultiplier;
this._cost += longPenalty; this._cost += longPenalty;
} }
if (ll > config.columnHardLimit) if (ll > config.max_line_length)
{ {
this._solved = false; this._solved = false;
break; break;
} }
i = j; i = j;
ll = indentLevel * config.indentSize; ll = indentLevel * config.indent_size;
if (b) if (b)
break; break;
} }

2
tests/test.sh
View File

@ -6,7 +6,7 @@ do
for source in *.d for source in *.d
do do
echo "${source}.ref" "${braceStyle}/${source}.out" echo "${source}.ref" "${braceStyle}/${source}.out"
../bin/dfmt --braces=${braceStyle} "${source}" > "${braceStyle}/${source}.out" ../bin/dfmt --brace_style=${braceStyle} "${source}" > "${braceStyle}/${source}.out"
diff -u "${braceStyle}/${source}.ref" "${braceStyle}/${source}.out" diff -u "${braceStyle}/${source}.ref" "${braceStyle}/${source}.out"
done done
done done