I was wondering if you would be interested in providing an alternative interface for writing, a func(string) in the config.

This would allow support for some special cases when using a carriage return to "reset" the displayed string is not supported.

This change introduces a 2KB (growable) byte buffer, to sit in between the painting function(s) and stdout. Previously, as we were animating the spinner we would write the bytes directly to stdout as we were generating the animation.

This change makes it so that most of our writes are to an in-memory buffer, and then we only have one system call to write to the actaul terminal the contents of that buffer.

This should act like a bit of a frame buffer, so if if anyone was experiencing any sort of stutter, where they could see the cursor as the spinner was animated, I believe this should result in a smoother adnimation.

This change is a small update to help make the spinner a bit more robust.

The first increases internal channel buffer size for frequency updates, to hopefully non-blocking write dropping an update. The buffer size increase is arbitrary, and calling .Frequency() in a hot loop could still result in dropped updates.

The second is the removal of a mutex lock within the Status() method, and an unnecessary nil check. There is not a need for either of them based on how the *Spinner is constructed.

The third is some refinemennt of the documentation both in comments on exported identifiers, and comments within the source code.

Hey, first off, love the lib! Great work!

I was wondering if you could provide some implementation advice. Refer to this stackoverflow question for the original question.

I refactored since the post, and almost have it working the way I would want it, but because I am stopping and then starting the spinner because before logger print, it is adding a new line which I cannot get rid off.

Any advice on how to fix this?

Currently, the output is:

Apr 19 01:05:29 INF  data=k

Apr 19 01:05:29 INF  data=m

Apr 19 01:05:29 INF  data=l
⣾13/26

What I am hoping for is (no extra newline):

Apr 19 01:05:29 INF  data=k
Apr 19 01:05:29 INF  data=m
Apr 19 01:05:29 INF  data=l
⣾13/26

This is my working code so far:

package main

import (
	"fmt"
	"os"
	"os/signal"
	"sync"
	"syscall"
	"time"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
	"github.com/theckman/yacspin"
)

var stdOut = zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: "Jan 02 15:04:05"}

func main() {
	var Logger = log.Output(stdOut)

	// pauseItForAMoment := false
	// create a spinner
	spinner, err := createSpinner()
	if err != nil {
		fmt.Printf("failed to make spinner from config struct: %v\n", err)
		os.Exit(1)
	}

	// start the spinner
	if err := spinner.Start(); err != nil {
		panic(err)
	}

	wg := &sync.WaitGroup{}
	wg.Add(1)
	var (
		total   int
		current int
	)

	data := make(chan string)

	// only want one go routine at a time but this is not important
	max := make(chan struct{}, 1)

	go func() {
		defer wg.Done()
		for d := range data {
			wg.Add(1)
			go func(wg *sync.WaitGroup, d string) {
				max <- struct{}{}
				defer func() {
					<-max
				}()

				// function is doing work and printing the result once done.
				// pauseItForAMoment = true
				// spinner.Prefix(d)
				if spinner.Status() == yacspin.SpinnerRunning {
					spinner.Stop()
				}

				// fmt.Println(d)
				Logger.Info().Str("data", d).Send()
				// fmt.Println(d)
				if spinner.Status() == yacspin.SpinnerStopped {
					spinner.Start()
				}
				current += 1
				spinner.Message(fmt.Sprintf("%d/%d", current, total))
				// pauseItForAMoment = false

				// sends a value to the spinner go routine so that it can show
				// the updated count
				time.Sleep(100 * time.Millisecond)
				// spinnerCh <- 1
				wg.Done()
			}(wg, d)
		}
	}()

	// simulate queing some work
	ss := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"}
	for _, s := range ss {
		data <- s
	}
	total = len(ss)

	close(data)
	wg.Wait()
	if err := spinner.Stop(); err != nil {
		spinner.StopFail()
	}
}

func createSpinner() (*yacspin.Spinner, error) {
	// build the configuration, each field is documented
	cfg := yacspin.Config{
		Frequency: 100 * time.Millisecond,
		CharSet:   yacspin.CharSets[11],
		Suffix:    "", // puts a least one space between the animating spinner and the Message
		// Message:           "collecting files",
		// SuffixAutoColon: true,
		// ColorAll:        true,
		Colors:        []string{"fgYellow"},
		StopCharacter: " ",
		StopColors:    []string{"fgGreen"},
		// StopMessage:       "done",
		StopFailCharacter: "✗",
		StopFailColors:    []string{"fgRed"},
		StopFailMessage:   "failed",
	}

	s, err := yacspin.New(cfg)
	if err != nil {
		return nil, fmt.Errorf("failed to make spinner from struct: %w", err)
	}

	return s, nil
}

func stopOnSignal(spinner *yacspin.Spinner) {
	// ensure we stop the spinner before exiting, otherwise cursor will remain
	// hidden and terminal will require a `reset`
	sigCh := make(chan os.Signal, 1)
	signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
	go func() {
		<-sigCh

		spinner.StopFailMessage("interrupted")

		// ignoring error intentionally
		_ = spinner.StopFail()

		os.Exit(0)
	}()
}

Thanks in advance!

This change adds a direct dependency on github.com/mattn/go-colorable to support Windows terminals, and removes the plumbing that hardcodes Windows as a dumb terminal. This is inspired by #32 opened by @OtisOat.

This also removes the vendor/ directory, as it's even less valuable with our usage of Modules.

Closes #32

This is a major update to the README and includes the following bits:

• History of why the project exists
• GIFs showing the differences between our package and others
• GIFs showing the full set of spinners

The name "delay" made more sense when the ability to update data was tied to the animation's frequency. Now that data updates happen independently from the spinner animating, it made more sense to make this the animation frequency.

It seems reasonable that someone may want a paused spinner to be stopped, without the user seeing another animation or data update. This supports Stop() and StopFail() working on a spinner whose Status() is SpinnerPaused.

Some of the things we were doing inside of the mutex weren't protected by the mutex itself. This reshuffles the code a bit to consider that and do as little inside of the mutex as we can.

This change adds three new methods to the Spinner type, and deprecates the Active method.

The first are the Pause() and Unpause() methods, which put the spinner in a paused state so that you can update multiple configuration options without users seeing a spinner rendered with partial changes applied. Such as changing the suffix, message, or colors.

The third method is the Status() method, which deprecates Active(). Because the internal state machine for the spinner has become more complex, it's no longer reasonable to consider it active or inactive. With this we include a new type, SpinnerStatus, and constants to represent each state of the internal state machine:

• SpinnerStopped
• SpinnerStarting
• SpinnerRunning
• SpinnerStoppping
• SpinnerPausing
• SpinnerPaused
• SpinnerUnpausing

Without this change, updates of data reset the timer making the animation no longer render smoothly.

This also fixes some potential race conditions with Start() or Stop() and any of the setter methods.

I'd love to update the message every tick of the spinner - would that be possible? with other (less functional) spinners, it's done by passing in a Preupdate/Postupdate function. Would that be possible?

I tried to use uilive to make multiple parallel spinners work based on this comment on stackoverflow.

The code itself looks like this:

package main

import (
	"fmt"
	"github.com/gosuri/uilive"
	"github.com/theckman/yacspin"
	"io"
	"time"
)

func main() {
	writer := uilive.New()
	writer2 := writer.Newline()
	writer.Start()
	defer writer.Stop()
	spinner1, _ := createSpinner1(writer)
	spinner2, _ := createSpinner2(writer2)
	spinner1.Start()
	time.Sleep(2 * time.Second)
	// update message
	spinner1.Message("uploading files")
	time.Sleep(2 * time.Second)
	spinner2.Start()
	time.Sleep(2 * time.Second)
	spinner1.Message("test")
	time.Sleep(2 * time.Second)
	spinner2.Stop()
	spinner1.Stop()
}

func createSpinner1(writer io.Writer) (*yacspin.Spinner, error) {
	// build the configuration, each field is documented
	cfg := yacspin.Config{
		Prefix:            "s1",
		Writer:            writer,
		Frequency:         100 * time.Millisecond,
		CharSet:           yacspin.CharSets[11],
		Suffix:            " ", // puts a least one space between the animating spinner and the Message
		Message:           "collecting files",
		SuffixAutoColon:   true,
		ColorAll:          true,
		Colors:            []string{"fgYellow"},
		StopCharacter:     "✓",
		StopColors:        []string{"fgGreen"},
		StopMessage:       "done",
		StopFailCharacter: "✗",
		StopFailColors:    []string{"fgRed"},
		StopFailMessage:   "failed",
	}

	s, err := yacspin.New(cfg)
	if err != nil {
		return nil, fmt.Errorf("failed to make spinner from struct: %w", err)
	}

	return s, nil
}
func createSpinner2(writer io.Writer) (*yacspin.Spinner, error) {
	// build the configuration, each field is documented
	cfg := yacspin.Config{
		Writer:            writer,
		Prefix:            "s2",
		Frequency:         100 * time.Millisecond,
		CharSet:           yacspin.CharSets[11],
		Suffix:            " ", // puts a least one space between the animating spinner and the Message
		Message:           "doing stuff",
		SuffixAutoColon:   true,
		ColorAll:          true,
		Colors:            []string{"fgYellow"},
		StopCharacter:     "✓",
		StopColors:        []string{"fgGreen"},
		StopMessage:       "done",
		StopFailCharacter: "✗",
		StopFailColors:    []string{"fgRed"},
		StopFailMessage:   "failed",
	}

	s, err := yacspin.New(cfg)
	if err != nil {
		return nil, fmt.Errorf("failed to make spinner from struct: %w", err)
	}

	return s, nil
}

I have absolutely no idea why this does not work as it should write to two different writers as in spinner.go in line 830 defined:

    if s.buffer.Len() > 0 {
		if _, err := s.writer.Write(s.buffer.Bytes()); err != nil {
			panic(fmt.Sprintf("failed to output buffer to writer: %v", err))
		}
	}

Could you please offer some assistance?

Thanks in advance.

It is sometimes desirable to log messages while rendering the spinner. Users can do this currently is by not setting a StopMessage and using Stop + Start to temporarily pause the spinner, remove the spinner text and log the message to standard output (example program below).

While this does work, I think it is worthwhile to add a spinner.LogMessage API that adds this functionality. Would love to contribute changes here if this idea makes sense.

package main

import (
	"fmt"
	"time"

	"github.com/theckman/yacspin"
)

func logProgress(spin *yacspin.Spinner, message string) {
	spin.Stop()
	fmt.Println(message)
	spin.Start()
}

func main() {
	spin, _ := yacspin.New(yacspin.Config{
		Frequency: time.Millisecond * 200,
		CharSet:   yacspin.CharSets[9],
		Message:   " Spinning...",
	})

	spin.Start()

	for i := 0; i < 10; i++ {
		logProgress(spin, fmt.Sprintf("Step %d completed.", i))
		time.Sleep(1000 * time.Millisecond)
	}

	spin.Stop()
}