use std::collections::HashMap;
use dprint_core::configuration::*;
use super::resolve_config::resolve_config;
use super::types::*;
pub struct ConfigurationBuilder {
pub(super) config: HashMap<String, String>,
global_config: Option<GlobalConfiguration>,
}
impl ConfigurationBuilder {
pub fn new() -> ConfigurationBuilder {
ConfigurationBuilder {
config: HashMap::new(),
global_config: None,
}
}
pub fn build(&self) -> Configuration {
if let Some(global_config) = &self.global_config {
resolve_config(self.config.clone(), global_config).config
} else {
let global_config = resolve_global_config(&HashMap::new()).config;
resolve_config(self.config.clone(), &global_config).config
}
}
pub fn global_config(&mut self, global_config: GlobalConfiguration) -> &mut Self {
self.global_config = Some(global_config);
self
}
pub fn deno(&mut self) -> &mut Self {
self.line_width(80)
.indent_width(2)
.next_control_flow_position(NextControlFlowPosition::SameLine)
.binary_expression_operator_position(OperatorPosition::SameLine)
.brace_position(BracePosition::SameLine)
.comment_line_force_space_after_slashes(false)
.construct_signature_space_after_new_keyword(true)
.constructor_type_space_after_new_keyword(true)
.arrow_function_use_parentheses(UseParentheses::Force)
.new_line_kind(NewLineKind::LineFeed)
.function_expression_space_after_function_keyword(true)
.tagged_template_space_before_literal(false)
.conditional_expression_prefer_single_line(true)
}
pub fn line_width(&mut self, value: u32) -> &mut Self {
self.insert("lineWidth", value)
}
pub fn use_tabs(&mut self, value: bool) -> &mut Self {
self.insert("useTabs", value)
}
pub fn indent_width(&mut self, value: u8) -> &mut Self {
self.insert("indentWidth", value)
}
pub fn new_line_kind(&mut self, value: NewLineKind) -> &mut Self {
self.insert("newLineKind", value)
}
pub fn quote_style(&mut self, value: QuoteStyle) -> &mut Self {
self.insert("quoteStyle", value)
}
pub fn semi_colons(&mut self, value: SemiColons) -> &mut Self {
self.insert("semiColons", value)
}
pub fn prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("preferHanging", value)
}
pub fn brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("bracePosition", value)
}
pub fn next_control_flow_position(&mut self, value: NextControlFlowPosition) -> &mut Self {
self.insert("nextControlFlowPosition", value)
}
pub fn operator_position(&mut self, value: OperatorPosition) -> &mut Self {
self.insert("operatorPosition", value)
}
pub fn single_body_position(&mut self, value: SingleBodyPosition) -> &mut Self {
self.insert("singleBodyPosition", value)
}
pub fn trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("trailingCommas", value)
}
pub fn use_braces(&mut self, value: UseBraces) -> &mut Self {
self.insert("useBraces", value)
}
pub fn prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("preferSingleLine", value)
}
pub fn binary_expression_space_surrounding_bitwise_and_arithmetic_operator(&mut self, value: bool) -> &mut Self {
self.insert("binaryExpression.spaceSurroundingBitwiseAndArithmeticOperator", value)
}
pub fn comment_line_force_space_after_slashes(&mut self, value: bool) -> &mut Self {
self.insert("commentLine.forceSpaceAfterSlashes", value)
}
pub fn construct_signature_space_after_new_keyword(&mut self, value: bool) -> &mut Self {
self.insert("constructSignature.spaceAfterNewKeyword", value)
}
pub fn constructor_space_before_parentheses(&mut self, value: bool) -> &mut Self {
self.insert("constructor.spaceBeforeParentheses", value)
}
pub fn constructor_type_space_after_new_keyword(&mut self, value: bool) -> &mut Self {
self.insert("constructorType.spaceAfterNewKeyword", value)
}
pub fn do_while_statement_space_after_while_keyword(&mut self, value: bool) -> &mut Self {
self.insert("doWhileStatement.spaceAfterWhileKeyword", value)
}
pub fn export_declaration_space_surrounding_named_exports(&mut self, value: bool) -> &mut Self {
self.insert("exportDeclaration.spaceSurroundingNamedExports", value)
}
pub fn for_statement_space_after_for_keyword(&mut self, value: bool) -> &mut Self {
self.insert("forStatement.spaceAfterForKeyword", value)
}
pub fn for_statement_space_after_semi_colons(&mut self, value: bool) -> &mut Self {
self.insert("forStatement.spaceAfterSemiColons", value)
}
pub fn for_in_statement_space_after_for_keyword(&mut self, value: bool) -> &mut Self {
self.insert("forInStatement.spaceAfterForKeyword", value)
}
pub fn for_of_statement_space_after_for_keyword(&mut self, value: bool) -> &mut Self {
self.insert("forOfStatement.spaceAfterForKeyword", value)
}
pub fn function_declaration_space_before_parentheses(&mut self, value: bool) -> &mut Self {
self.insert("functionDeclaration.spaceBeforeParentheses", value)
}
pub fn function_expression_space_before_parentheses(&mut self, value: bool) -> &mut Self {
self.insert("functionExpression.spaceBeforeParentheses", value)
}
pub fn function_expression_space_after_function_keyword(&mut self, value: bool) -> &mut Self {
self.insert("functionExpression.spaceAfterFunctionKeyword", value)
}
pub fn get_accessor_space_before_parentheses(&mut self, value: bool) -> &mut Self {
self.insert("getAccessor.spaceBeforeParentheses", value)
}
pub fn if_statement_space_after_if_keyword(&mut self, value: bool) -> &mut Self {
self.insert("ifStatement.spaceAfterIfKeyword", value)
}
pub fn import_declaration_space_surrounding_named_imports(&mut self, value: bool) -> &mut Self {
self.insert("importDeclaration.spaceSurroundingNamedImports", value)
}
pub fn jsx_expression_container_space_surrounding_expression(&mut self, value: bool) -> &mut Self {
self.insert("jsxExpressionContainer.spaceSurroundingExpression", value)
}
pub fn method_space_before_parentheses(&mut self, value: bool) -> &mut Self {
self.insert("method.spaceBeforeParentheses", value)
}
pub fn set_accessor_space_before_parentheses(&mut self, value: bool) -> &mut Self {
self.insert("setAccessor.spaceBeforeParentheses", value)
}
pub fn tagged_template_space_before_literal(&mut self, value: bool) -> &mut Self {
self.insert("taggedTemplate.spaceBeforeLiteral", value)
}
pub fn type_annotation_space_before_colon(&mut self, value: bool) -> &mut Self {
self.insert("typeAnnotation.spaceBeforeColon", value)
}
pub fn type_assertion_space_before_expression(&mut self, value: bool) -> &mut Self {
self.insert("typeAssertion.spaceBeforeExpression", value)
}
pub fn while_statement_space_after_while_keyword(&mut self, value: bool) -> &mut Self {
self.insert("whileStatement.spaceAfterWhileKeyword", value)
}
pub fn arrow_function_use_parentheses(&mut self, value: UseParentheses) -> &mut Self {
self.insert("arrowFunction.useParentheses", value)
}
pub fn arrow_function_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("arrowFunction.bracePosition", value)
}
pub fn class_declaration_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("classDeclaration.bracePosition", value)
}
pub fn class_expression_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("classExpression.bracePosition", value)
}
pub fn constructor_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("constructor.bracePosition", value)
}
pub fn do_while_statement_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("doWhileStatement.bracePosition", value)
}
pub fn enum_declaration_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("enumDeclaration.bracePosition", value)
}
pub fn for_statement_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("forStatement.bracePosition", value)
}
pub fn for_in_statement_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("forInStatement.bracePosition", value)
}
pub fn for_of_statement_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("forOfStatement.bracePosition", value)
}
pub fn get_accessor_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("getAccessor.bracePosition", value)
}
pub fn if_statement_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("ifStatement.bracePosition", value)
}
pub fn interface_declaration_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("interfaceDeclaration.bracePosition", value)
}
pub fn function_declaration_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("functionDeclaration.bracePosition", value)
}
pub fn function_expression_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("functionExpression.bracePosition", value)
}
pub fn method_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("method.bracePosition", value)
}
pub fn module_declaration_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("moduleDeclaration.bracePosition", value)
}
pub fn set_accessor_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("setAccessor.bracePosition", value)
}
pub fn switch_case_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("switchCase.bracePosition", value)
}
pub fn switch_statement_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("switchStatement.bracePosition", value)
}
pub fn try_statement_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("tryStatement.bracePosition", value)
}
pub fn while_statement_brace_position(&mut self, value: BracePosition) -> &mut Self {
self.insert("whileStatement.bracePosition", value)
}
pub fn arguments_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("arguments.preferHanging", value)
}
pub fn array_expression_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("arrayExpression.preferHanging", value)
}
pub fn array_pattern_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("arrayPattern.preferHanging", value)
}
pub fn do_while_statement_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("doWhileStatement.preferHanging", value)
}
pub fn export_declaration_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("exportDeclaration.preferHanging", value)
}
pub fn extends_clause_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("extendsClause.preferHanging", value)
}
pub fn for_in_statement_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("forInStatement.preferHanging", value)
}
pub fn for_of_statement_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("forOfStatement.preferHanging", value)
}
pub fn for_statement_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("forStatement.preferHanging", value)
}
pub fn if_statement_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("ifStatement.preferHanging", value)
}
pub fn implements_clause_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("implementsClause.preferHanging", value)
}
pub fn import_declaration_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("importDeclaration.preferHanging", value)
}
pub fn object_expression_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("objectExpression.preferHanging", value)
}
pub fn object_pattern_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("objectPattern.preferHanging", value)
}
pub fn parameters_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("parameters.preferHanging", value)
}
pub fn sequence_expression_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("sequenceExpression.preferHanging", value)
}
pub fn switch_statement_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("switchStatement.preferHanging", value)
}
pub fn tuple_type_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("tupleType.preferHanging", value)
}
pub fn type_literal_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("typeLiteral.preferHanging", value)
}
pub fn type_parameter_declaration_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("typeParameterDeclaration.preferHanging", value)
}
pub fn union_and_intersection_type_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("unionAndIntersectionType.preferHanging", value)
}
pub fn variable_statement_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("variableStatement.preferHanging", value)
}
pub fn while_statement_prefer_hanging(&mut self, value: bool) -> &mut Self {
self.insert("whileStatement.preferHanging", value)
}
pub fn enum_declaration_member_spacing(&mut self, value: MemberSpacing) -> &mut Self {
self.insert("enumDeclaration.memberSpacing", value)
}
pub fn if_statement_next_control_flow_position(&mut self, value: NextControlFlowPosition) -> &mut Self {
self.insert("ifStatement.nextControlFlowPosition", value)
}
pub fn try_statement_next_control_flow_position(&mut self, value: NextControlFlowPosition) -> &mut Self {
self.insert("tryStatement.nextControlFlowPosition", value)
}
pub fn binary_expression_operator_position(&mut self, value: OperatorPosition) -> &mut Self {
self.insert("binaryExpression.operatorPosition", value)
}
pub fn conditional_expression_operator_position(&mut self, value: OperatorPosition) -> &mut Self {
self.insert("conditionalExpression.operatorPosition", value)
}
pub fn if_statement_single_body_position(&mut self, value: SingleBodyPosition) -> &mut Self {
self.insert("ifStatement.singleBodyPosition", value)
}
pub fn for_statement_single_body_position(&mut self, value: SingleBodyPosition) -> &mut Self {
self.insert("forStatement.singleBodyPosition", value)
}
pub fn for_in_statement_single_body_position(&mut self, value: SingleBodyPosition) -> &mut Self {
self.insert("forInStatement.singleBodyPosition", value)
}
pub fn for_of_statement_single_body_position(&mut self, value: SingleBodyPosition) -> &mut Self {
self.insert("forOfStatement.singleBodyPosition", value)
}
pub fn while_statement_single_body_position(&mut self, value: SingleBodyPosition) -> &mut Self {
self.insert("whileStatement.singleBodyPosition", value)
}
pub fn arguments_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("arguments.trailingCommas", value)
}
pub fn parameters_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("parameters.trailingCommas", value)
}
pub fn array_expression_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("arrayExpression.trailingCommas", value)
}
pub fn array_pattern_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("arrayPattern.trailingCommas", value)
}
pub fn enum_declaration_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("enumDeclaration.trailingCommas", value)
}
pub fn export_declaration_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("exportDeclaration.trailingCommas", value)
}
pub fn import_declaration_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("importDeclaration.trailingCommas", value)
}
pub fn object_expression_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("objectExpression.trailingCommas", value)
}
pub fn object_pattern_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("objectPattern.trailingCommas", value)
}
pub fn tuple_type_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("tupleType.trailingCommas", value)
}
pub fn type_parameter_declaration_trailing_commas(&mut self, value: TrailingCommas) -> &mut Self {
self.insert("typeParameterDeclaration.trailingCommas", value)
}
pub fn if_statement_use_braces(&mut self, value: UseBraces) -> &mut Self {
self.insert("ifStatement.useBraces", value)
}
pub fn for_statement_use_braces(&mut self, value: UseBraces) -> &mut Self {
self.insert("forStatement.useBraces", value)
}
pub fn for_in_statement_use_braces(&mut self, value: UseBraces) -> &mut Self {
self.insert("forInStatement.useBraces", value)
}
pub fn for_of_statement_use_braces(&mut self, value: UseBraces) -> &mut Self {
self.insert("forOfStatement.useBraces", value)
}
pub fn while_statement_use_braces(&mut self, value: UseBraces) -> &mut Self {
self.insert("whileStatement.useBraces", value)
}
pub fn array_expression_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("arrayExpression.preferSingleLine", value)
}
pub fn array_pattern_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("arrayPattern.preferSingleLine", value)
}
pub fn arguments_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("arguments.preferSingleLine", value)
}
pub fn conditional_expression_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("conditionalExpression.preferSingleLine", value)
}
pub fn import_declaration_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("importDeclaration.preferSingleLine", value)
}
pub fn export_declaration_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("exportDeclaration.preferSingleLine", value)
}
pub fn object_expression_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("objectExpression.preferSingleLine", value)
}
pub fn object_pattern_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("objectPattern.preferSingleLine", value)
}
pub fn parameters_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("parameters.preferSingleLine", value)
}
pub fn tuple_type_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("tupleType.preferSingleLine", value)
}
pub fn type_literal_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("typeLiteral.preferSingleLine", value)
}
pub fn variable_statement_prefer_single_line(&mut self, value: bool) -> &mut Self {
self.insert("variableStatement.preferSingleLine", value)
}
#[cfg(test)]
pub(super) fn get_inner_config(&self) -> HashMap<String, String> {
self.config.clone()
}
fn insert<T>(&mut self, name: &str, value: T) -> &mut Self where T : std::string::ToString {
self.config.insert(String::from(name), value.to_string());
self
}
}