Fixes special characters in connection url string. Fixes #25

components/ConnectionForm.go

@@ -1,6 +1,8 @@
 package components
 
 import (
+	"net/url"
+
 	"github.com/jorgerojas26/lazysql/drivers"
 	"github.com/jorgerojas26/lazysql/helpers"
 	"github.com/jorgerojas26/lazysql/models"
@@ -76,7 +78,7 @@ func (form *ConnectionForm) inputCapture(connectionPages *models.ConnectionPages
 				return event
 			}
 
-			connectionString := form.GetFormItem(1).(*tview.InputField).GetText()
+			connectionString := helpers.EscapeConnectionString(form.GetFormItem(1).(*tview.InputField).GetText())
 
 			parsed, err := helpers.ParseConnectionString(connectionString)
 
@@ -151,9 +153,31 @@ func (form *ConnectionForm) inputCapture(connectionPages *models.ConnectionPages
 func (form *ConnectionForm) testConnection(connectionString string) {
 	form.StatusText.SetText("Connecting...").SetTextColor(tcell.ColorGreen)
 
+	parsed, err := helpers.ParseConnectionString(connectionString)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	password, _ := parsed.User.Password()
+	DBName := helpers.ParsedDBName(parsed.Path)
+
+	escapedConnection := models.Connection{
+		Name:     "",
+		Provider: parsed.Driver,
+		User:     url.QueryEscape(parsed.User.Username()),
+		Password: password,
+		Host:     parsed.Host,
+		Port:     parsed.Port(),
+		DBName:   DBName,
+		Query:    url.QueryEscape(parsed.Query().Encode()),
+		DSN:      url.QueryEscape(parsed.DSN),
+	}
+
+	escapedConnectionString := helpers.ConnectionToURL(&escapedConnection)
+
 	db := drivers.MySQL{}
 
-	err := db.TestConnection(connectionString)
+	err = db.TestConnection(escapedConnectionString)
 
 	if err != nil {
 		form.StatusText.SetText(err.Error()).SetTextStyle(tcell.StyleDefault.Foreground(tcell.ColorRed))

components/ConnectionSelection.go

@@ -2,6 +2,7 @@ package components
 
 import (
 	"fmt"
+	"net/url"
 	"strings"
 
 	"github.com/jorgerojas26/lazysql/app"
@@ -69,30 +70,15 @@ func NewConnectionSelection(connectionForm *ConnectionForm, connectionPages *mod
 		if len(connections) != 0 {
 			row, _ := ConnectionListTable.GetSelection()
 			selectedConnection := connections[row]
-			queryParams := selectedConnection.Query
-			dbNamePath := selectedConnection.DBName
 
-			connectionUrl := fmt.Sprintf("%s://%s:%s@%s:%s", selectedConnection.Provider, selectedConnection.User, selectedConnection.Password, selectedConnection.Host, selectedConnection.Port)
-
-			if selectedConnection.Provider == "sqlite3" {
-				connectionUrl = fmt.Sprintf("file:%s", selectedConnection.DSN)
-			} else {
-				if dbNamePath != "" {
-					connectionUrl = fmt.Sprintf("%s/%s", connectionUrl, dbNamePath)
-				}
-
-				if queryParams != "" {
-					connectionUrl = fmt.Sprintf("%s?%s", connectionUrl, queryParams)
-				}
-
-			}
+			connectionURL := helpers.ConnectionToURL(&selectedConnection)
 
 			if event.Rune() == 'c' || event.Key() == tcell.KeyEnter {
-				go cs.connect(connectionUrl, selectedConnection.Name)
+				go cs.connect(selectedConnection)
 			} else if event.Rune() == 'e' {
 				connectionPages.SwitchToPage("ConnectionForm")
 				connectionForm.GetFormItemByLabel("Name").(*tview.InputField).SetText(selectedConnection.Name)
-				connectionForm.GetFormItemByLabel("URL").(*tview.InputField).SetText(connectionUrl)
+				connectionForm.GetFormItemByLabel("URL").(*tview.InputField).SetText(connectionURL)
 				connectionForm.StatusText.SetText("")
 
 				connectionForm.SetAction("edit")
@@ -142,19 +128,24 @@ func NewConnectionSelection(connectionForm *ConnectionForm, connectionPages *mod
 	return cs
 }
 
-func (cs *ConnectionSelection) connect(connectionUrl string, connectionTitle string) {
-	parsed, _ := helpers.ParseConnectionString(connectionUrl)
+func (cs *ConnectionSelection) connect(connection models.Connection) {
+	connectionURL := helpers.ConnectionToURL(&connection)
+	cs.StatusText.SetText("")
+
+	selectedRow, selectedCol := ConnectionListTable.GetSelection()
+	cell := ConnectionListTable.GetCell(selectedRow, selectedCol)
+	cell.SetText(fmt.Sprintf("[green]* %s", cell.Text))
 
-	if MainPages.HasPage(connectionUrl) {
-		MainPages.SwitchToPage(connectionUrl)
+	if MainPages.HasPage(connectionURL) {
+		MainPages.SwitchToPage(connectionURL)
 		App.Draw()
 	} else {
 		cs.StatusText.SetText("Connecting...").SetTextColor(tcell.ColorGreen)
 		App.Draw()
 
 		var newDbDriver drivers.Driver
 
-		switch parsed.Driver {
+		switch connection.Provider {
 		case "mysql":
 			newDbDriver = &drivers.MySQL{}
 		case "postgres":
@@ -163,28 +154,38 @@ func (cs *ConnectionSelection) connect(connectionUrl string, connectionTitle str
 			newDbDriver = &drivers.SQLite{}
 		}
 
-		err := newDbDriver.Connect(connectionUrl)
+		escapedConnection := models.Connection{
+			Name:     connection.Name,
+			Provider: connection.Provider,
+			User:     url.PathEscape(connection.User),
+			Password: url.PathEscape(connection.Password),
+			Host:     connection.Host,
+			Port:     connection.Port,
+			DBName:   connection.DBName,
+			Query:    connection.Query,
+			DSN:      connection.DSN,
+		}
+
+		escapedConnectionString := helpers.ConnectionToURL(&escapedConnection)
+
+		err := newDbDriver.Connect(escapedConnectionString)
 
 		if err != nil {
 			cs.StatusText.SetText(err.Error()).SetTextStyle(tcell.StyleDefault.Foreground(tcell.ColorRed))
 			App.Draw()
 		} else {
-			newHome := NewHomePage(connectionUrl, newDbDriver)
+			newHome := NewHomePage(escapedConnectionString, newDbDriver)
 
-			MainPages.AddAndSwitchToPage(connectionUrl, newHome, true)
+			MainPages.AddAndSwitchToPage(connectionURL, newHome, true)
 
 			cs.StatusText.SetText("")
 			App.Draw()
 
-			selectedRow, selectedCol := ConnectionListTable.GetSelection()
-			cell := ConnectionListTable.GetCell(selectedRow, selectedCol)
-			cell.SetText(fmt.Sprintf("[green]* %s", cell.Text))
-
 			ConnectionListTable.SetCell(selectedRow, selectedCol, cell)
 
-			MainPages.SwitchToPage(connectionUrl)
+			MainPages.SwitchToPage(connectionURL)
 			newHome.Tree.SetCurrentNode(newHome.Tree.GetRoot())
-			newHome.Tree.SetTitle(fmt.Sprintf("%s (%s)", connectionTitle, strings.ToUpper(parsed.UnaliasedDriver)))
+			newHome.Tree.SetTitle(fmt.Sprintf("%s (%s)", connection.Name, strings.ToUpper(connection.Provider)))
 			App.SetFocus(newHome.Tree)
 			App.Draw()
 		}

components/Home.go

@@ -24,12 +24,7 @@ type Home struct {
 }
 
 func NewHomePage(name string, dbdriver drivers.Driver) *Home {
-	parsed, err := helpers.ParseConnectionString(name)
-	if err != nil {
-		panic(err.Error())
-	}
-
-	dbName := helpers.ParsedDBName(parsed.Path)
+	dbName := helpers.GetDBName(name)
 
 	tree := NewTree(dbName, dbdriver)
 	tabbedPane := NewTabbedPane()

helpers/utils.go

@@ -1,15 +1,56 @@
 package helpers
 
 import (
+	"fmt"
+	"net/url"
 	"strings"
 
+	"github.com/jorgerojas26/lazysql/models"
 	"github.com/xo/dburl"
 )
 
 func ParseConnectionString(url string) (*dburl.URL, error) {
 	return dburl.Parse(url)
 }
 
+func EscapeConnectionString(urlstr string) string {
+	connectionString := urlstr
+
+	splitConnection := strings.Split(connectionString, "://")
+
+	if len(splitConnection) > 1 {
+		if strings.Contains(connectionString, "?") {
+			splitPath := strings.Split(splitConnection[1], "?")
+
+			connectionString = splitConnection[0] + "://" + url.PathEscape(splitPath[0]) + "?" + splitPath[1]
+		} else {
+			connectionString = splitConnection[0] + "://" + url.PathEscape(splitConnection[1])
+		}
+	}
+	return connectionString
+}
+
+func ConnectionToURL(connection *models.Connection) string {
+	connectionUrl := fmt.Sprintf("%s://%s:%s@%s:%s", connection.Provider, connection.User, connection.Password, connection.Host, connection.Port)
+
+	queryParams := connection.Query
+	dbNamePath := connection.DBName
+
+	if connection.Provider == "sqlite3" {
+		connectionUrl = fmt.Sprintf("file:%s", connection.DSN)
+	} else {
+		if dbNamePath != "" {
+			connectionUrl = fmt.Sprintf("%s/%s", connectionUrl, dbNamePath)
+		}
+
+		if queryParams != "" {
+			connectionUrl = fmt.Sprintf("%s?%s", connectionUrl, queryParams)
+		}
+
+	}
+	return connectionUrl
+}
+
 func GetDBName(url string) string {
 	return strings.Split(url, "/")[1]
 }