Softened Outptut's name validation

Author: goloop

go.mod

@@ -7,4 +7,4 @@ require (
 	github.com/goloop/trit v1.7.1
 )
 
-require github.com/goloop/is v1.3.0
+require github.com/goloop/is v1.4.0

go.sum

@@ -10,6 +10,8 @@ github.com/goloop/is v1.2.0 h1:dPsFRmcfrcz+DktkICGsq9mS+5mNC94xNv3LHXrZ8DQ=
 github.com/goloop/is v1.2.0/go.mod h1:wrFW9DTFePYdWXH1Y8ZGUWOi8N8XCZ3vMsV9xald618=
 github.com/goloop/is v1.3.0 h1:4Kw2r3PZNXEmI17HsfTZP7NBxZk+S2hxRXx7xBDEBXY=
 github.com/goloop/is v1.3.0/go.mod h1:wrFW9DTFePYdWXH1Y8ZGUWOi8N8XCZ3vMsV9xald618=
+github.com/goloop/is v1.4.0 h1:Ha9kvgku6AScWcNx/J9gq3iiD+XAqIRum09JgtRv2Zk=
+github.com/goloop/is v1.4.0/go.mod h1:wrFW9DTFePYdWXH1Y8ZGUWOi8N8XCZ3vMsV9xald618=
 github.com/goloop/trit v1.2.0 h1:BrJg7mfI3AHli40FA3Q77MH3MY/oSbbdgt58bwrmkyc=
 github.com/goloop/trit v1.2.0/go.mod h1:DVMcZPI0c2vjgl/F7SXsAE3AsDDEdVnAofRhnzqFsi0=
 github.com/goloop/trit v1.3.0 h1:SnYIt1qfiW+mT9pfd+FGlrWpbvEkGAywoflKdFFJUvs=

log_test.go

@@ -187,11 +187,22 @@ func TestSetOutputs(t *testing.T) {
 					Writer: os.Stdout,
 				},
 			},
-			names:  []string{"test"},
+			names:  []string{},
 			hasErr: true,
 		},
 		{
-			name: "Wrong output name, but is system output",
+			name: "CSS-style output name",
+			in: []Output{
+				{
+					Name:   "file-name",
+					Writer: os.Stdout,
+				},
+			},
+			names:  []string{"file-name"},
+			hasErr: false,
+		},
+		{
+			name: "Wrong output name, but it is system output",
 			in: []Output{
 				{
 					Name:     "*",

logger.go

@@ -67,19 +67,21 @@ const (
 	// to the JSON block); printf - \n is appended to the JSON block* and the
 	// message format matches the specified user format.
 	//
-	// So, to determine if a custom format pattern is specified, we use two
-	// constants formatStr and formatStrLn, which help determine the type of
-	// function (print, println, or printf) that renders the message, and the
-	// formatting methods for text or JSON style.
+	// So, to determine if a custom format pattern is specified, we use
+	// two constants formatPrint and formatPrintln, which help determine
+	// the type of function (print, println, or printf) that renders
+	// the message, and the formatting methods for text or JSON style.
 	//
 	//  * JSON block is the final text representation of the logger in
 	//   JSON format written as text.
 
-	// The formatStr is the system format string for print-type functions.
-	formatStr = "format: string-without-a-newline-character"
+	// The formatPrint is the system format string
+	// for print-type functions.
+	formatPrint = "{$ string-without-a-newline-character $}"
 
-	// The formatStrLn is the system format string for println-type functions.
-	formatStrLn = "format: string-with-a-newline-character"
+	// The formatPrintln is the system format string
+	// for println-type functions.
+	formatPrintln = "{$ string-with-a-newline-character $}"
 )
 
 var (
@@ -147,6 +149,8 @@ type Output struct {
 	// The name must sound like a variable name in most programming languages:
 	// it must have special characters, not start with a number, etc.
 	// But the name can be a reserved word like return, for, if ... any.
+	// The name can also be expressed as a selector name in CSS,
+	// for example "some-log-file" (without the leading . or # symbols).
 	Name string
 
 	// Writer is the point where the login data will be output,
@@ -440,7 +444,7 @@ func (logger *Logger) SetOutputs(outputs ...Output) error {
 		// The name must be specified.
 		if g.IsEmpty(o.Name) {
 			return fmt.Errorf("the %d output has empty name", i)
-		} else if !o.isSystem && !is.Var(o.Name) {
+		} else if !o.isSystem && !is.SelectorName(o.Name, true) {
 			return fmt.Errorf("the %d output has incorrect name '%s'",
 				i, o.Name)
 		}
@@ -640,7 +644,7 @@ func (logger *Logger) echo(w io.Writer, l level.Level, f string, a ...any) {
 // for its operands and writes to w. Spaces are added between operands
 // when neither is a string.
 func (logger *Logger) Fpanic(w io.Writer, a ...any) {
-	logger.echo(w, level.Panic, formatStr, a...)
+	logger.echo(w, level.Panic, formatPrint, a...)
 	panic(fmt.Sprint(a...))
 }
 
@@ -655,15 +659,15 @@ func (logger *Logger) Fpanicf(w io.Writer, format string, a ...any) {
 // for its operands and writes to w. Spaces are always added between
 // operands and a newline is appended.
 func (logger *Logger) Fpanicln(w io.Writer, a ...any) {
-	logger.echo(w, level.Panic, formatStrLn, a...)
+	logger.echo(w, level.Panic, formatPrintln, a...)
 	panic(fmt.Sprintln(a...))
 }
 
 // Panic creates message with Panic level, using the default formats
 // for its operands and writes to log.Writer. Spaces are added between
 // operands when neither is a string.
 func (logger *Logger) Panic(a ...any) {
-	logger.echo(nil, level.Panic, formatStr, a...)
+	logger.echo(nil, level.Panic, formatPrint, a...)
 	panic(fmt.Sprint(a...))
 }
 
@@ -678,15 +682,15 @@ func (logger *Logger) Panicf(format string, a ...any) {
 // for its operands and writes to log.Writer. Spaces are always added
 // between operands and a newline is appended.
 func (logger *Logger) Panicln(a ...any) (int, error) {
-	logger.echo(nil, level.Panic, formatStrLn, a...)
+	logger.echo(nil, level.Panic, formatPrintln, a...)
 	panic(fmt.Sprintln(a...))
 }
 
 // Ffatal creates message with Fatal level, using the default formats
 // for its operands and writes to w. Spaces are added between operands
 // when neither is a string.
 func (logger *Logger) Ffatal(w io.Writer, a ...any) {
-	logger.echo(w, level.Fatal, formatStr, a...)
+	logger.echo(w, level.Fatal, formatPrint, a...)
 	exit(logger.fatalStatusCode)
 }
 
@@ -701,15 +705,15 @@ func (logger *Logger) Ffatalf(w io.Writer, format string, a ...any) {
 // for its operands and writes to w. Spaces are always added between
 // operands and a newline is appended.
 func (logger *Logger) Ffatalln(w io.Writer, a ...any) {
-	logger.echo(w, level.Fatal, formatStrLn, a...)
+	logger.echo(w, level.Fatal, formatPrintln, a...)
 	exit(logger.fatalStatusCode)
 }
 
 // Fatal creates message with Fatal level, using the default formats
 // for its operands and writes to log.Writer. Spaces are added between
 // operands when neither is a string.
 func (logger *Logger) Fatal(a ...any) {
-	logger.echo(nil, level.Fatal, formatStr, a...)
+	logger.echo(nil, level.Fatal, formatPrint, a...)
 	exit(logger.fatalStatusCode)
 }
 
@@ -724,15 +728,15 @@ func (logger *Logger) Fatalf(format string, a ...any) {
 // for its operands and writes to log.Writer. Spaces are always added
 // between operands and a newline is appended.
 func (logger *Logger) Fatalln(a ...any) {
-	logger.echo(nil, level.Fatal, formatStrLn, a...)
+	logger.echo(nil, level.Fatal, formatPrintln, a...)
 	exit(logger.fatalStatusCode)
 }
 
 // Ferror creates message with Error level, using the default formats
 // for its operands and writes to w. Spaces are added between operands
 // when neither is a string.
 func (logger *Logger) Ferror(w io.Writer, a ...any) {
-	logger.echo(w, level.Error, formatStr, a...)
+	logger.echo(w, level.Error, formatPrint, a...)
 }
 
 // Ferrorf creates message with Error level, according to a format
@@ -745,14 +749,14 @@ func (logger *Logger) Ferrorf(w io.Writer, f string, a ...any) {
 // for its operands and writes to w. Spaces are always added between
 // operands and a newline is appended.
 func (logger *Logger) Ferrorln(w io.Writer, a ...any) {
-	logger.echo(w, level.Error, formatStrLn, a...)
+	logger.echo(w, level.Error, formatPrintln, a...)
 }
 
 // Error creates message with Error level, using the default formats
 // for its operands and writes to log.Writer. Spaces are added between
 // operands when neither is a string.
 func (logger *Logger) Error(a ...any) {
-	logger.echo(nil, level.Error, formatStr, a...)
+	logger.echo(nil, level.Error, formatPrint, a...)
 }
 
 // Errorf creates message with Error level, according to a format specifier
@@ -765,14 +769,14 @@ func (logger *Logger) Errorf(f string, a ...any) {
 // for its operands and writes to log.Writer. Spaces are always added
 // between operands and a newline is appended.
 func (logger *Logger) Errorln(a ...any) {
-	logger.echo(nil, level.Error, formatStrLn, a...)
+	logger.echo(nil, level.Error, formatPrintln, a...)
 }
 
 // Fwarn creates message with Warn level, using the default formats
 // for its operands and writes to w. Spaces are added between operands
 // when neither is a string.
 func (logger *Logger) Fwarn(w io.Writer, a ...any) {
-	logger.echo(w, level.Warn, formatStr, a...)
+	logger.echo(w, level.Warn, formatPrint, a...)
 }
 
 // Fwarnf creates message with Warn level, according to a format
@@ -785,14 +789,14 @@ func (logger *Logger) Fwarnf(w io.Writer, format string, a ...any) {
 // for its operands and writes to w. Spaces are always added between
 // operands and a newline is appended.
 func (logger *Logger) Fwarnln(w io.Writer, a ...any) {
-	logger.echo(w, level.Warn, formatStrLn, a...)
+	logger.echo(w, level.Warn, formatPrintln, a...)
 }
 
 // Warn creates message with Warn level, using the default formats
 // for its operands and writes to log.Writer. Spaces are added between
 // operands when neither is a string.
 func (logger *Logger) Warn(a ...any) {
-	logger.echo(nil, level.Warn, formatStr, a...)
+	logger.echo(nil, level.Warn, formatPrint, a...)
 }
 
 // Warnf creates message with Warn level, according to a format specifier
@@ -805,14 +809,14 @@ func (logger *Logger) Warnf(format string, a ...any) {
 // for its operands and writes to log.Writer. Spaces are always added
 // between operands and a newline is appended.
 func (logger *Logger) Warnln(a ...any) {
-	logger.echo(nil, level.Warn, formatStrLn, a...)
+	logger.echo(nil, level.Warn, formatPrintln, a...)
 }
 
 // Finfo creates message with Info level, using the default formats
 // for its operands and writes to w. Spaces are added between operands
 // when neither is a string.
 func (logger *Logger) Finfo(w io.Writer, a ...any) {
-	logger.echo(w, level.Info, formatStr, a...)
+	logger.echo(w, level.Info, formatPrint, a...)
 }
 
 // Finfof creates message with Info level, according to a format
@@ -825,14 +829,14 @@ func (logger *Logger) Finfof(w io.Writer, format string, a ...any) {
 // for its operands and writes to w. Spaces are always added between
 // operands and a newline is appended.
 func (logger *Logger) Finfoln(w io.Writer, a ...any) {
-	logger.echo(w, level.Info, formatStrLn, a...)
+	logger.echo(w, level.Info, formatPrintln, a...)
 }
 
 // Info creates message with Info level, using the default formats
 // for its operands and writes to log.Writer. Spaces are added between
 // operands when neither is a string.
 func (logger *Logger) Info(a ...any) {
-	logger.echo(nil, level.Info, formatStr, a...)
+	logger.echo(nil, level.Info, formatPrint, a...)
 }
 
 // Infof creates message with Info level, according to a format specifier
@@ -845,14 +849,14 @@ func (logger *Logger) Infof(format string, a ...any) {
 // for its operands and writes to log.Writer. Spaces are always added
 // between operands and a newline is appended.
 func (logger *Logger) Infoln(a ...any) {
-	logger.echo(nil, level.Info, formatStrLn, a...)
+	logger.echo(nil, level.Info, formatPrintln, a...)
 }
 
 // Fdebug creates message with Debug level, using the default formats
 // for its operands and writes to w. Spaces are added between operands
 // when neither is a string.
 func (logger *Logger) Fdebug(w io.Writer, a ...any) {
-	logger.echo(w, level.Debug, formatStr, a...)
+	logger.echo(w, level.Debug, formatPrint, a...)
 }
 
 // Fdebugf creates message with Debug level, according to a format
@@ -865,14 +869,14 @@ func (logger *Logger) Fdebugf(w io.Writer, format string, a ...any) {
 // for its operands and writes to w. Spaces are always added between
 // operands and a newline is appended.
 func (logger *Logger) Fdebugln(w io.Writer, a ...any) {
-	logger.echo(w, level.Debug, formatStrLn, a...)
+	logger.echo(w, level.Debug, formatPrintln, a...)
 }
 
 // Debug creates message with Debug level, using the default formats
 // for its operands and writes to log.Writer. Spaces are added between
 // operands when neither is a string.
 func (logger *Logger) Debug(a ...any) {
-	logger.echo(nil, level.Debug, formatStr, a...)
+	logger.echo(nil, level.Debug, formatPrint, a...)
 }
 
 // Debugf creates message with Debug level, according to a format specifier
@@ -886,14 +890,14 @@ func (logger *Logger) Debugf(format string, a ...any) {
 // for its operands and writes to log.Writer. Spaces are always added
 // between operands and a newline is appended.
 func (logger *Logger) Debugln(a ...any) {
-	logger.echo(nil, level.Debug, formatStrLn, a...)
+	logger.echo(nil, level.Debug, formatPrintln, a...)
 }
 
 // Ftrace creates message with Trace level, using the default formats
 // for its operands and writes to w. Spaces are added between operands
 // when neither is a string.
 func (logger *Logger) Ftrace(w io.Writer, a ...any) {
-	logger.echo(w, level.Trace, formatStr, a...)
+	logger.echo(w, level.Trace, formatPrint, a...)
 }
 
 // Ftracef creates message with Trace level, according to a format
@@ -906,14 +910,14 @@ func (logger *Logger) Ftracef(w io.Writer, format string, a ...any) {
 // for its operands and writes to w. Spaces are always added between
 // operands and a newline is appended.
 func (logger *Logger) Ftraceln(w io.Writer, a ...any) {
-	logger.echo(w, level.Trace, formatStrLn, a...)
+	logger.echo(w, level.Trace, formatPrintln, a...)
 }
 
 // Trace creates message with Trace level, using the default formats
 // for its operands and writes to log.Writer. Spaces are added between
 // operands when neither is a string.
 func (logger *Logger) Trace(a ...any) {
-	logger.echo(nil, level.Trace, formatStr, a...)
+	logger.echo(nil, level.Trace, formatPrint, a...)
 }
 
 // Tracef creates message with Trace level, according to a format specifier
@@ -926,5 +930,5 @@ func (logger *Logger) Tracef(format string, a ...any) {
 // for its operands and writes to log.Writer. Spaces are always added
 // between operands and a newline is appended.
 func (logger *Logger) Traceln(a ...any) {
-	logger.echo(nil, level.Trace, formatStrLn, a...)
+	logger.echo(nil, level.Trace, formatPrintln, a...)
 }

logger_test.go

@@ -108,13 +108,13 @@ func TestEchoWithTextFormatting(t *testing.T) {
 		},
 		{
 			name:   "System formatStr",
-			format: formatStr,
+			format: formatPrint,
 			in:     []interface{}{"hello", "world"},
 			want:   "helloworld", // used fmt.Print
 		},
 		{
 			name:   "System formatStrLn",
-			format: formatStrLn,
+			format: formatPrintln,
 			in:     []interface{}{"hello", "world"},
 			want:   " hello world\n", // used fmt.Println
 		},
@@ -165,13 +165,13 @@ func TestEchoWithJSONFormatting(t *testing.T) {
 		},
 		{
 			name:   "System formatStr",
-			format: formatStr,
+			format: formatPrint,
 			in:     []interface{}{"hello", "world"},
 			want:   "helloworld", // used fmt.Print
 		},
 		{
 			name:   "System formatStrLn",
-			format: formatStrLn,
+			format: formatPrintln,
 			in:     []interface{}{"hello", "world"},
 			want:   "hello world", // used fmt.Println with Trim
 		},

tools.go

@@ -147,13 +147,13 @@ func textMessage(
 	switch {
 	case f == "":
 		fallthrough
-	case f == formatStr:
+	case f == formatPrint:
 		// For messages that are output on the same line, the task of
 		// separating the messages falls on the user. We don't need to
 		// add extra characters to user messages.
 		// msg = fmt.Sprintf("%s%s%s", sb.String(), fmt.Sprint(a...), o.Space)
 		msg = fmt.Sprintf("%s%s", sb.String(), fmt.Sprint(a...))
-	case f == formatStrLn:
+	case f == formatPrintln:
 		msg = fmt.Sprintf("%s%s", sb.String(), fmt.Sprintln(a...))
 	default:
 		msg = fmt.Sprintf("%s%s", sb.String(), fmt.Sprintf(f, a...))
@@ -223,9 +223,9 @@ func objectMessage(
 	switch {
 	case f == "":
 		fallthrough
-	case f == formatStr:
+	case f == formatPrint:
 		obj.Message = fmt.Sprint(a...)
-	case f == formatStrLn:
+	case f == formatPrintln:
 		obj.Message = strings.TrimSuffix(fmt.Sprintln(a...), "\n")
 	default:
 		obj.Message = fmt.Sprintf(f, a...)
@@ -241,7 +241,7 @@ func objectMessage(
 	switch {
 	case f == "":
 		fallthrough
-	case f == formatStr:
+	case f == formatPrint:
 		msg = fmt.Sprintf("%s%s", data, o.Space)
 	default: // for formatStrLn and others
 		msg = fmt.Sprintf("%s\n", data)