Merge pull request #16 from pocke/15-convert-line-ending

[WIP] Convert line ending

Author: pocke

Makefile

@@ -1,13 +1,13 @@
 VERSION=$(shell git describe --tags)
 
 build:
-	go build -ldflags "-X main.version=$(VERSION)"
+	go build -ldflags "-X github.com/pocke/lemonade/lemon.Version=$(VERSION)"
 
 install:
-	go install -ldflags "-X main.version=$(VERSION)"
+	go install -ldflags "-X github.com/pocke/lemonade/lemon.Version=$(VERSION)"
 
 release:
-	gox --arch 'amd64 386' --os 'windows linux darwin' --output "dist/{{.Dir}}_{{.OS}}_{{.Arch}}/{{.Dir}}" -ldflags "-X main.version=$(VERSION)"
+	gox --arch 'amd64 386' --os 'windows linux darwin' --output "dist/{{.Dir}}_{{.OS}}_{{.Arch}}/{{.Dir}}" -ldflags "-X github.com/pocke/lemonade/lemon.Version=$(VERSION)"
 	zip      pkg/lemonade_windows_386.zip     dist/lemonade_windows_386/lemonade.exe   -j
 	zip      pkg/lemonade_windows_amd64.zip   dist/lemonade_windows_amd64/lemonade.exe -j
 	tar zcvf pkg/lemonade_linux_386.tar.gz    -C dist/lemonade_linux_386/    lemonade

README.md

@@ -50,7 +50,8 @@ Sub Commands:
 
 Options:
   --port=2489                 TCP port number
-  --allow="0.0.0.0/0,::0"     Allow IP Range             [Server only]
+  --line-ending               Convert Line Ending(CR/CRLF)
+  --allow="0.0.0.0/0,::/0"    Allow IP Range             [Server only]
   --host="localhost"          Destination hostname       [Client only]
   --trans-loopback=true       Translate loopback address [open subcommand only]
   --trans-localfile=true      Translate local file path  [open subcommand only]
@@ -91,6 +92,7 @@ There is configuration file at `~/.config/lemonade.toml`.
 ```toml
 port = 1234
 allow = '192.168.0.0/24'
+line-ending = 'crlf'
 ```
 
 - `port` is a listening port of TCP.
@@ -104,6 +106,7 @@ port = 1234
 host = '192.168.x.x'
 trans-loopback = true
 trans-localfile = true
+line-ending = 'crlf'
 ```
 
 - `port` is a port of server.
@@ -152,6 +155,14 @@ If this option is true, server receives IP address of client. And client serve t
 So, server can open the local file!
 
 
+### line-ending
+
+Default: "" (NONE)
+
+This options works with `copy` and `paste` command only.
+
+If this option is `lf` or `crlf`, lemonade converts the line ending of text to the specified.
+
 
 ### Alias
 

cli.go

@@ -9,19 +9,22 @@ import (
 	"net/rpc"
 	"os"
 
+	"github.com/pocke/lemonade/lemon"
 	"github.com/pocke/lemonade/param"
 	"github.com/pocke/lemonade/server"
 )
 
 type client struct {
-	host string
-	port int
+	host       string
+	port       int
+	lineEnding string
 }
 
-func New(host string, port int) *client {
+func New(c *lemon.CLI) *client {
 	return &client{
-		host: host,
-		port: port,
+		host:       c.Host,
+		port:       c.Port,
+		lineEnding: c.LineEnding,
 	}
 }
 
@@ -94,7 +97,7 @@ func (c *client) Paste() (string, error) {
 		return "", err
 	}
 
-	return resp, nil
+	return lemon.ConvertLineEnding(resp, c.lineEnding), nil
 }
 
 func (c *client) Copy(text string) error {
@@ -108,7 +111,7 @@ func (c *client) withRPCClient(f func(*rpc.Client) error) error {
 	if err != nil {
 		log.Println(err)
 		log.Println("Fall back to localhost")
-		rc, err = fallbackLocal()
+		rc, err = c.fallbackLocal()
 		if err != nil {
 			return err
 		}
@@ -121,8 +124,9 @@ func (c *client) withRPCClient(f func(*rpc.Client) error) error {
 	return nil
 }
 
-func fallbackLocal() (*rpc.Client, error) {
+func (c *client) fallbackLocal() (*rpc.Client, error) {
 	port, err := server.ServeLocal()
+	server.LineEndingOpt = c.lineEnding
 	if err != nil {
 		return nil, err
 	}

client/client.go

@@ -0,0 +1,45 @@
+package lemon
+
+import "io"
+
+type CommandType int
+
+// Commands
+const (
+	OPEN CommandType = iota + 1
+	COPY
+	PASTE
+	SERVER
+)
+
+const (
+	Success        = 0
+	FlagParseError = iota + 10
+	RPCError
+	Help
+)
+
+type CommandStyle int
+
+const (
+	ALIAS CommandStyle = iota + 1
+	SUBCOMMAND
+)
+
+type CLI struct {
+	In       io.Reader
+	Out, Err io.Writer
+
+	Type       CommandType
+	DataSource string
+
+	// options
+	Port           int
+	Allow          string
+	Host           string
+	TransLoopback  bool
+	TransLocalfile bool
+	LineEnding     string
+
+	Help bool
+}

lemon/cli.go

@@ -1,4 +1,4 @@
-package main
+package lemon
 
 import (
 	"flag"
@@ -74,6 +74,7 @@ func (c *CLI) flags() *flag.FlagSet {
 	flags.BoolVar(&c.Help, "help", false, "Show this message")
 	flags.BoolVar(&c.TransLoopback, "trans-loopback", true, "Translate loopback address")
 	flags.BoolVar(&c.TransLocalfile, "trans-localfile", true, "Translate local file")
+	flags.StringVar(&c.LineEnding, "line-ending", "", "Convert Line Ending(CR/CRLF)")
 	return flags
 }
 

flag.go renamed to lemon/flag.go

@@ -1,4 +1,4 @@
-package main
+package lemon
 
 import (
 	"os"

flag_test.go renamed to lemon/flag_test.go

@@ -0,0 +1,42 @@
+package lemon
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+var Version string
+var Usage = fmt.Sprintf(`Usage: lemonade [options]... SUB_COMMAND [arg]
+Sub Commands:
+  open [URL]                  Open URL by browser
+  copy [text]                 Copy text.
+  paste                       Paste text.
+  server                      Start lemonade server.
+
+Options:
+  --port=2489                 TCP port number
+  --line-ending               Convert Line Ending(CR/CRLF)
+  --allow="0.0.0.0/0,::/0"    Allow IP Range             [Server only]
+  --host="localhost"          Destination hostname       [Client only]
+  --trans-loopback=true       Translate loopback address [open subcommand only]
+  --trans-localfile=true      Translate local file path  [open subcommand only]
+  --help                      Show this message
+
+
+Version:
+  %s`, Version)
+
+func ConvertLineEnding(text, option string) string {
+	switch option {
+	case "lf", "LF":
+		text = strings.Replace(text, "\r\n", "\n", -1)
+		return strings.Replace(text, "\r", "\n", -1)
+	case "crlf", "CRLF":
+		text = regexp.MustCompile(`\r(.)|\r$`).ReplaceAllString(text, "\r\n$1")
+		text = regexp.MustCompile(`([^\r])\n|^\n`).ReplaceAllString(text, "$1\r\n")
+		return text
+	default:
+		return text
+	}
+}

lemon/main.go

@@ -0,0 +1,22 @@
+package lemon
+
+import "testing"
+
+func TestConvertLineEnding(t *testing.T) {
+	assert := func(text, option, expected string) {
+		if got := ConvertLineEnding(text, option); got != expected {
+			t.Errorf("Expected: %+v, got %+v", []byte(expected), []byte(got))
+		}
+	}
+
+	assert("aaa\r\nbbb", "lf", "aaa\nbbb")
+	assert("aaa\rbbb", "lf", "aaa\nbbb")
+	assert("aaa\nbbb", "lf", "aaa\nbbb")
+
+	assert("aaa\r\nbbb", "crlf", "aaa\r\nbbb")
+	assert("aaa\rbbb", "crlf", "aaa\r\nbbb")
+	assert("aaa\nbbb", "crlf", "aaa\r\nbbb")
+
+	assert("a\r", "crlf", "a\r\n")
+	assert("\na", "crlf", "\r\na")
+}