update readme: add ci badge

* WIP executable
* interlacing issues w/ hyperlinks

.drone.yml

@@ -0,0 +1,11 @@
+---
+kind: pipeline
+type: docker
+name: default
+
+steps:
+- name: test
+  image: golang:1.13
+  commands:
+  - go get ./...
+  - go test -v -race -cover -coverprofile ./coverage.out ./...

README.md

@@ -3,181 +3,188 @@
 [![Go version](https://img.shields.io/badge/go_version-1.11-blue.svg)](https://golang.org/doc/go1.11)
 [![Go Report Card](https://goreportcard.com/badge/git.xdrm.io/go/clifmt)](https://goreportcard.com/report/git.xdrm.io/go/clifmt)
 [![Go doc](https://godoc.org/git.xdrm.io/go/clifmt?status.svg)](https://godoc.org/git.xdrm.io/go/clifmt)
-[![buddy branch](https://app.buddy.works/xdrmbracketsdev/clifmt/repository/branch/master/badge.svg?token=33f90a953be299fc439c760e2eab36c708f8ea1f87f1159dd77924589b364b2d "buddy branch")](https://app.buddy.works/xdrmbracketsdev/clifmt/repository/branch/master)
+[![Build Status](https://drone.xdrm.io/api/badges/go/clifmt/status.svg)](https://drone.xdrm.io/go/clifmt)
 
 
-Simple utility written in `go` that extends the standard `fmt.Sprintf` and `fmt.Printf` functions. It allows you to set foreground/background color, **bold**, <u>underlined</u> and _italic_ text.
+Simple utility written in `go` that extends the standard `fmt.Sprintf` and `fmt.Printf` functions. It allows you to set foreground/background color, **bold**, <u>underlined</u>, _italic_ text and [hyperlinks](some-url).
 
 <!-- toc -->
 
-- [(1) Format](#1-format)
+- [I. How to use](#i-how-to-use)
-  * [[Colorization]](#colorization)
+  * [1) Requirements](#1-requirements)
-    + [Base format](#base-format)
+  * [2) Installation](#2-installation)
-        * [Example](#example)
+  * [3) Usage](#3-usage)
-    + [Foreground only](#foreground-only)
+    + [a) As a library](#a-as-a-library)
-        * [Example](#example-1)
+    + [b) As an executable](#b-as-an-executable)
-    + [Background only](#background-only)
+- [II. Format syntax](#ii-format-syntax)
-        * [Example](#example-2)
+  * [1) Text style](#1-text-style)
-  * [[Markdown-like format]](#markdown-like-format)
+- [III. Animations](#iii-animations)
-    + [Bold format](#bold-format)
+- [IV. Screenshots](#iv-screenshots)
-        * [Example](#example-3)
-    + [Italic format](#italic-format)
-        * [Example](#example-4)
-    + [Underline format](#underline-format)
-        * [Example](#example-5)
-    + [Hyperlink format](#hyperlink-format)
-        * [Example](#example-6)
-- [(2) Screenshot](#2-screenshot)
     * [Colorizing format example :](#colorizing-format-example-)
     * [Markdown-like format example](#markdown-like-format-example)
-- [(3) Incoming features](#3-incoming-features)
+- [V. Incoming features](#v-incoming-features)
 
 <!-- tocstop -->
 
 ----
+## I. How to use
 
-## (1) Format
+### 1) Requirements
+
+The package **clifmt** can be used as a `go` library or as an executable. In either case, you need :
+
+- any recent linux system (_has not been tested over other OSes_)
+- `go` installed (_has not been tested under version **1.11**_)
 
 
 
-### [Colorization]
+### 2) Installation
 
-#### Base format
+Simply launch the following command in your favorite terminal
 
-```go
+```bash
-${<target text>}(<fg>:<bg>)
+$ go get -u git.xdrm.io/go/clifmt
 ```
 
-- `<target text>` is the text that will be colorized.
+> It will download the project sources into _`$GOPATH`/src/git.xdrm.io/go/clifmt_.
-
-- `<fg>` is the name of the foreground color (*c.f. [color list](https://git.xdrm.io/go/clifmt/src/master/colors.go#L15)*), or an hex color (*e.g.`#00ffaa`, `#0fa`*).
-
-- `<bg>` is the name of the background color with the same syntax as for the foreground.
 
 
 
-###### Example
+### 3) Usage
+
+#### a) As a library
+
+You must import the library into your program with
 
 ```go
-clifmt.Printf("normal text ${red text over black}(red:#000) normal text")
+import "git.xdrm.io/go/clifmt"
-```
-
-> Note that it is not recommended to nest the different coloring formats.
-
-
-
-#### Foreground only
-
-```go
-${<target text>}(<fg>)
-```
-
-- `<target text>` is the text that will be colorized.
-- `<fg>` is the name of the foreground color.
-
-
-
-###### Example
-
-```go
-clifmt.Printf("normal text ${red text}(red) normal text")
 ```
 
 
 
-#### Background only
+Then, the following methods will be available
 
 ```go
-${<target text>}(:<bg>)
+// Printf wraps the standard fmt.Printf() features but adds formatting capabilities
+func Printf(fmt string, args ...interface{}) error
 ```
 
-- `<target text>` is the text that will be colorized.
+```go
-- `<bg>` is the name of the background color.
+// Sprintf acts as 'Printf' but returns the string instead of printing it
-
+func Sprintf(fmt string, args ...interface{}) (string, error)
-
+```
-
-###### Example
 
 ```go
-clifmt.Printf("normal text ${text over red}(#ff0000) normal text")
+// Printpf acts as 'Printf' but takes as arguments either standard fmt.Printf arguments, or channels that will update the output when provided with correct values.
+func Printpf(fmt string, args ...interface{}) (error)
 ```
 
 
 
-### [Markdown-like format]
+#### b) As an executable
+
+You must run from your terminal
+
+```bash
+$ go get -u git.xdrm.io/go/clifmt/cmd/clifmt
+```
+The  `clifmt` executable will be available in your $GOBIN directory.
+
+> WARNING: The executable tool is a Work In Progress, it is not stable for now. You can use `clifmt --help` anyway to see details on the format, coloring, etc.
+
+
+----
+
+## II. Format syntax
 
 
 
-#### Bold format
+### 1) Text style
+
+
+
+The format has been designed with the markdown syntax in mind, but has some differences due to implementation issues and for stability.
+
+
+
+The format is better described by the sample below than explanations :
 
 ```go
-**<target text>**
+// markdown-like
+Printf("some normal text")
+Printf("**some bold text**")
+Printf("*some italic text*")
+Printf("_some underline text_")
+Printf("[link label](http://link_url)")
+
+// colors
+Printf("${red text}(red)")
+Printf("${red text over blue background}(red:blue)")
+Printf("${blue background text}(:blue)")
 ```
 
-- `<target text>` is the text that will be bold.
+The code below will print the following result :
 
-###### Example
+![definition example result](https://0x0.st/zrtE.png)
+
+> Any syntax feature (_e.g. bold, color, hyperlink, ..._) can be included in any other. In the same way any syntax feature can be interlaced (_e.g. "startA startB stopA stopB"_) with each other.
+
+> Note that there can be some issues with interlaced hyperlinks as it is supported as other syntax features. But it works perfectly when used alone.
+
+> Color names (_e.g. **red**, **blue**_) can be replaced by their hexadecimal representation (_e.g. **#ff0000**, **#0000ff**_) or the short version (_e.g. **#f00**, **#00f**_).
+
+----
+
+## III. Animations
+
+The **Printpf**  method allows you to pass [channels](https://tour.golang.org/concurrency/2) among ordinary arguments. It allows you to animate the text you want to print each time you send data on a channel argument.
+
+
+
+The example below shows a simple progress bar using markdown-like syntax, colors and animations :
 
 ```go
-clifmt.Printf("normal text **bold text** normal text")
+package main
+
+import (
+	"git.xdrm.io/go/clifmt"
+	"time"
+)
+
+func main() {
+    // (1) animated values
+	var (
+		status   = make(chan interface{})
+		color    = make(chan interface{})
+		progress = make(chan interface{})
+	)
+
+    // (2) print your animated values
+	go clifmt.Printpf("[${%s}(%s)] **%d**%%", status, color, progress)
+
+    // (3) animate values
+	status <- "download"
+	color <- "red"
+	for i := 0; i < 100; i++ {
+		progress <- i
+		time.Sleep(time.Millisecond * 200)
+	}
+	status <- "done"
+	color <- "green"
+}
 ```
 
+The result is the following :
+
+![animation result](https://cloud.xdrm.io/s/go_clifmt_anim_result/download)
 
 
-#### Italic format
-
-```go
-*<target text>*
-```
-
-- `<target text>` is the text that will be italic.
-
-###### Example
-
-```go
-clifmt.Printf("normal text *italic text* normal text")
-```
-
-
-
-#### Underline format
-
-```go
-_<target text>_
-```
-
-- `<target text>` is the text that will be underlined.
-
-###### Example
-
-```go
-clifmt.Printf("normal text _underline text_ normal text")
-```
-
-
-
-
-
-#### Hyperlink format
-
-```go
-[<target text>](<target url>)
-```
-
-- `<target text>` is the text that will be displayed.
-- `<target url>` is the url the hyperlink links to.
-
-###### Example
-
-```go
-clifmt.Printf("normal text [hyper](link) normal text")
-```
 
 
 
 ----
 
-## (2) Screenshot
+## IV. Screenshots
 
 
 
@@ -195,9 +202,10 @@ clifmt.Printf("normal text [hyper](link) normal text")
 
 ----
 
-## (3) Incoming features
+## V. Incoming features
 
 - [x] **markdown-like formatting** - bold, italic, underlined, (strike-through?)
+- [ ] **command-line executable** - align text from terminal
 - [ ] **global alignment** - align text dynamically
-- [ ] **progress-line** - redrawing format to show, for instance an animated progress bar on the same line
+- [x] **progress-line** - redrawing format to show, for instance an animated progress bar on the same line
 

go.mod

@@ -0,0 +1,3 @@
+module git.xdrm.io/go/clifmt
+
+go 1.12

internal/syntax/hyperlink/hyperlink.go

@@ -10,14 +10,17 @@ type export string
 var Export = export("hyperlink")
 
 func (syn export) Regex() *regexp.Regexp {
-	return regexp.MustCompile(`(?m)\[([^\[]+)\]\(([^\)]+)\)`)
+	return regexp.MustCompile(`(?m)(^|[^\x1b])\[([^(?:\]()]+)\]\(([^\)]+)\)`)
 }
 
 func (syn export) Transform(args ...string) (string, error) {
 	// no arg, empty -> ignore
-	if len(args) < 2 || len(args[0]) < 1 {
+	if len(args) < 2 || len(args[1]) < 1 {
 		return "", nil
 	}
 
-	return fmt.Sprintf("\x1b]8;;%s\x1b\\%s\x1b]8;;\x1b\\", args[1], args[0]), nil
+	linkstart := fmt.Sprintf("\x1b]8;;%s\x1b\\", args[2])
+	linkend := fmt.Sprintf("\x1b]8;;\x1b\\")
+
+	return fmt.Sprintf("%s%s%s%s", args[0], linkstart, args[1], linkend), nil
 }

progress.go

@@ -2,7 +2,6 @@ package clifmt
 
 import (
 	"fmt"
-	"math"
 	"reflect"
 	"strings"
 )
@@ -58,10 +57,12 @@ func Printpf(format string, args ...interface{}) error {
 		}
 
 		// (4) rewind N lines (written previous time)
-		if rows >= 0 {
+		if rows > 0 {
 			fmt.Printf("\x1b[%dF\x1b[K", rows)
+		} else {
+			fmt.Printf("\r\x1b[K")
 		}
-		rows = int(math.Max(float64(strings.Count(str, "\n")), 1))
+		rows = strings.Count(str, "\n")
 
 		// (5) make each line rewrite previous line
 		str = strings.Replace(str, "\n", "\n\x1b[K", 11)