logr.NewLogr -> logr.NewFromSlogHandler

The new name makes more sense for the function in the main package, for
symmetry with logr.New. In slogr, the same name as before is
used (slogr.NewLogr).

context_slog.go

@@ -36,7 +36,7 @@ func FromContext(ctx context.Context) (Logger, error) {
 	case Logger:
 		return v, nil
 	case *slog.Logger:
-		return NewLogr(v.Handler()), nil
+		return NewFromSlogHandler(v.Handler()), nil
 	default:
 		// Not reached.
 		panic(fmt.Sprintf("unexpected value type for logr context key: %T", v))

slogr.go

@@ -24,11 +24,11 @@ import (
 	"log/slog"
 )
 
-// NewLogr returns a Logger which writes to the slog.Handler.
+// NewFromSlogHandler returns a Logger which writes to the slog.Handler.
 //
 // The logr verbosity level is mapped to slog levels such that V(0) becomes
 // slog.LevelInfo and V(4) becomes slog.LevelDebug.
-func NewLogr(handler slog.Handler) Logger {
+func NewFromSlogHandler(handler slog.Handler) Logger {
 	if handler, ok := handler.(*slogHandler); ok {
 		if handler.sink == nil {
 			return Discard()

slogr/slogr.go

@@ -36,7 +36,7 @@ import (
 // The logr verbosity level is mapped to slog levels such that V(0) becomes
 // slog.LevelInfo and V(4) becomes slog.LevelDebug.
 func NewLogr(handler slog.Handler) logr.Logger {
-	return logr.NewLogr(handler)
+	return logr.NewFromSlogHandler(handler)
 }
 
 // NewSlogHandler returns a slog.Handler which writes to the same sink as the logr.Logger.

slogr_test.go

@@ -48,8 +48,8 @@ var debugWithoutTime = &slog.HandlerOptions{
 	Level: slog.LevelDebug,
 }
 
-func ExampleNew() {
-	logrLogger := logr.NewLogr(slog.NewTextHandler(os.Stdout, debugWithoutTime))
+func ExampleNewFromSlogHandler() {
+	logrLogger := logr.NewFromSlogHandler(slog.NewTextHandler(os.Stdout, debugWithoutTime))
 
 	logrLogger.Info("hello world")
 	logrLogger.Error(errors.New("fake error"), "ignore me")
@@ -91,7 +91,7 @@ func TestWithCallDepth(t *testing.T) {
 	debugWithCaller := *debugWithoutTime
 	debugWithCaller.AddSource = true
 	var buffer bytes.Buffer
-	logger := logr.NewLogr(slog.NewTextHandler(&buffer, &debugWithCaller))
+	logger := logr.NewFromSlogHandler(slog.NewTextHandler(&buffer, &debugWithCaller))
 
 	logHelper(logger)
 	_, file, line, _ := runtime.Caller(0)
@@ -228,22 +228,22 @@ func TestDiscard(t *testing.T) {
 
 func TestConversion(t *testing.T) {
 	d := logr.Discard()
-	d2 := logr.NewLogr(logr.NewSlogHandler(d))
+	d2 := logr.NewFromSlogHandler(logr.NewSlogHandler(d))
 	expectEqual(t, d, d2)
 
 	e := logr.Logger{}
-	e2 := logr.NewLogr(logr.NewSlogHandler(e))
+	e2 := logr.NewFromSlogHandler(logr.NewSlogHandler(e))
 	expectEqual(t, e, e2)
 
 	f := funcr.New(func(prefix, args string) {}, funcr.Options{})
-	f2 := logr.NewLogr(logr.NewSlogHandler(f))
+	f2 := logr.NewFromSlogHandler(logr.NewSlogHandler(f))
 	expectEqual(t, f, f2)
 
 	text := slog.NewTextHandler(io.Discard, nil)
-	text2 := logr.NewSlogHandler(logr.NewLogr(text))
+	text2 := logr.NewSlogHandler(logr.NewFromSlogHandler(text))
 	expectEqual(t, text, text2)
 
-	text3 := logr.NewSlogHandler(logr.NewLogr(text).V(1))
+	text3 := logr.NewSlogHandler(logr.NewFromSlogHandler(text).V(1))
 	if handler, ok := text3.(interface {
 		GetLevel() slog.Level
 	}); ok {

slogsink.go

@@ -32,7 +32,7 @@ var (
 	_ Underlier        = &slogSink{}
 )
 
-// Underlier is implemented by the LogSink returned by NewLogr.
+// Underlier is implemented by the LogSink returned by NewFromLogHandler.
 type Underlier interface {
 	// GetUnderlying returns the Handler used by the LogSink.
 	GetUnderlying() slog.Handler