to use default parameter, change name of methods.

js/src/main/scala/com/github/vertical_blank/sqlformatter/scala/SqlFormatter.scala

@@ -12,19 +12,16 @@ private[scala] object Facade extends js.Object {
 
 object SqlFormatter extends AbstractSqlFormatter {
   def format(sql: String,
-             language: SQLLanguage,
-             indent: String): String =
-    Facade.format(sql, js.Dictionary("language" -> language.name, "indent" -> indent))
+             config: FormatConfig): String =
+    Facade.format(sql, js.Dictionary("language" -> config.dialect.name, "indent" -> config.indent))
 
-  def format(sql: String,
+  def formatWithNamedParams(sql: String,
              params: Map[String, Any],
-             language: SQLLanguage,
-             indent: String): String =
-    Facade.format(sql, js.Dictionary("language" -> language.name, "indent" -> indent, "params" -> params.toJSDictionary))
+             config: FormatConfig): String =
+    Facade.format(sql, js.Dictionary("language" -> config.dialect.name, "indent" -> config.indent, "params" -> params.toJSDictionary))
 
-  def format(sql: String,
+  def formatWithIndexedParams(sql: String,
              params: Seq[Any],
-             language: SQLLanguage,
-             indent: String): String =
-    Facade.format(sql, js.Dictionary("language" -> language.name, "indent" -> indent, "params" -> params.toJSArray))
+             config: FormatConfig): String =
+    Facade.format(sql, js.Dictionary("language" -> config.dialect.name, "indent" -> config.indent, "params" -> params.toJSArray))
 }

jvm/src/main/scala/com/github/vertical_blank/sqlformatter/scala/SqlFormatter.scala

@@ -5,17 +5,13 @@ import com.github.vertical_blank.sqlformatter.{SqlFormatter => JSqlFormatter}
 
 object SqlFormatter extends AbstractSqlFormatter {
   def format(sql: String,
-             language: SQLLanguage,
-             indent: String): String = JSqlFormatter.of(language.name).format(sql, indent)
+             config: FormatConfig): String = JSqlFormatter.of(config.dialect.name).format(sql, config.indent)
 
-
-  def format(sql: String,
+  def formatWithNamedParams(sql: String,
              params: Map[String, Any],
-             language: SQLLanguage,
-             indent: String): String = JSqlFormatter.of(language.name).format(sql, indent, params.asJava)
+             config: FormatConfig): String = JSqlFormatter.of(config.dialect.name).format(sql, config.indent, params.asJava)
 
-  def format(sql: String,
+  def formatWithIndexedParams(sql: String,
              params: Seq[Any],
-             language: SQLLanguage,
-             indent: String): String = JSqlFormatter.of(language.name).format(sql, indent, params.asJava)
+             config: FormatConfig): String = JSqlFormatter.of(config.dialect.name).format(sql, config.indent, params.asJava)
 }

readme.md

@@ -25,3 +25,65 @@ SELECT
 FROM
   table1
 ```
+
+### Dialect
+
+You can pass dialect with `FormatConfig` :
+
+```scala
+SqlFormatter.format(
+  "SELECT *",
+  FormatConfig(dialect = SqlDialect.CouchbaseN1QL))
+```
+
+Currently just four SQL dialects are supported:
+
+- StandardSQL - [Standard SQL](https://en.wikipedia.org/wiki/SQL:2011)
+- CouchbaseN1QL - [Couchbase N1QL](http://www.couchbase.com/n1ql)
+- DB2 - [IBM DB2](https://www.ibm.com/analytics/us/en/technology/db2/)
+- PLSQL - [Oracle PL/SQL](http://www.oracle.com/technetwork/database/features/plsql/index.html)
+
+### Format
+
+Defaults to two spaces.
+You can pass indent string with `FormatConfig` to `format` :
+
+```scala
+SqlFormatter.format(
+  "SELECT * FROM table1",
+  FormatConfig(indent = "    "))
+```
+
+This will output:
+
+```sql
+SELECT
+    *
+FROM
+    table1
+```
+
+### Placeholders replacement
+
+You can pass `Seq` to `formatWithIndexedParams`, or `Map` to `formatWithNamedParams` :
+
+```scala
+// Named placeholders
+SqlFormatter.formatWithNamedParams("SELECT * FROM tbl WHERE foo = @foo", params = Map("foo" -> "'bar'"))
+
+// Indexed placeholders
+SqlFormatter.formatWithIndexedParams("SELECT * FROM tbl WHERE foo = ?", params = Seq("'bar'"))
+```
+
+Both result in:
+
+```sql
+SELECT
+  *
+FROM
+  tbl
+WHERE
+  foo = 'bar'
+```
+
+Same as the `format` method, `formatWithNamedParams` and `formatWithIndexedParams` accept `dialect` and `indent` parameters.

shared/src/main/scala/com/github/vertical_blank/sqlformatter/scala/AbstractSqlFormatter.scala

@@ -1,29 +1,14 @@
 package com.github.vertical_blank.sqlformatter.scala
 
 trait AbstractSqlFormatter {
-  final def format(sql: String): String =
-    format(sql, SQLLanguage.StandardSQL, indent = "  ")
 
-  final def format(sql: String, indent: String): String =
-    format(sql, SQLLanguage.StandardSQL, indent = indent)
+  def format(sql: String, config: FormatConfig = FormatConfig()): String
 
-  final def format(sql: String, params: Map[String, Any]): String =
-    format(sql, params, SQLLanguage.StandardSQL, indent = "  ")
-
-  final def format(sql: String, params: Seq[Any]): String =
-    format(sql, params, SQLLanguage.StandardSQL, indent = "  ")
-
-  def format(sql: String,
-             language: SQLLanguage,
-             indent: String): String
-
-  def format(sql: String,
+  def formatWithNamedParams(sql: String,
              params: Map[String, Any],
-             language: SQLLanguage,
-             indent: String): String
+             config: FormatConfig = FormatConfig()): String
 
-  def format(sql: String,
+  def formatWithIndexedParams(sql: String,
              params: Seq[Any],
-             language: SQLLanguage ,
-             indent: String): String
+             config: FormatConfig = FormatConfig()): String
 }

shared/src/main/scala/com/github/vertical_blank/sqlformatter/scala/FormatConfig.scala

@@ -0,0 +1,5 @@
+package com.github.vertical_blank.sqlformatter.scala
+
+case class FormatConfig(
+  dialect: SqlDialect = SqlDialect.StandardSQL,
+  indent: String = "  ")

shared/src/main/scala/com/github/vertical_blank/sqlformatter/scala/SqlDialect.scala

@@ -0,0 +1,9 @@
+package com.github.vertical_blank.sqlformatter.scala
+
+sealed abstract class SqlDialect(val name: String) extends Product with Serializable
+object SqlDialect {
+  case object StandardSQL extends SqlDialect("sql")
+  case object CouchbaseN1QL extends SqlDialect("n1ql")
+  case object DB2 extends SqlDialect("db2")
+  case object PLSQL extends SqlDialect("pl/sql")
+}

shared/src/test/scala/com/github/vertical_blank/sqlformatter/scala/BaseTest.scala

@@ -34,20 +34,18 @@ abstract class BaseTest(sqlFormatter: AbstractSqlFormatter) extends FunSuite {
                        |    table""".stripMargin
 
     assert(sqlFormatter
-      .format("SELECT foo, bar, CASE baz WHEN 'one' THEN 1 WHEN 'two' THEN 2 ELSE 3 END FROM table", indent = "    ") == formatted)
+      .format("SELECT foo, bar, CASE baz WHEN 'one' THEN 1 WHEN 'two' THEN 2 ELSE 3 END FROM table", FormatConfig(indent = "    ")) == formatted)
   }
 
   test("withNamedParams") {
-    val namedParams = Map("foo" -> "'bar'")
-
     val formatted = """|SELECT
                        |  *
                        |FROM
                        |  table
                        |WHERE
                        |  foo = 'bar'""".stripMargin
 
-    assert(sqlFormatter.format("SELECT * FROM table WHERE foo = @foo", namedParams) == formatted)
+    assert(sqlFormatter.formatWithNamedParams("SELECT * FROM table WHERE foo = @foo", params = Map("foo" -> "'bar'")) == formatted)
   }
 
   test("withIndexedParams") {
@@ -59,6 +57,6 @@ abstract class BaseTest(sqlFormatter: AbstractSqlFormatter) extends FunSuite {
                        |WHERE
                        |  foo = 'bar'""".stripMargin
 
-    assert(sqlFormatter.format("SELECT * FROM table WHERE foo = ?", Seq("'bar'")) == formatted)
+    assert(sqlFormatter.formatWithIndexedParams("SELECT * FROM table WHERE foo = ?", params = Seq("'bar'")) == formatted)
   }
 }