philiprehberger-progress 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba10a34300c085657e70aed11c006694d2c0ea2dccba5e0ea82a6c04fce1c50f
-  data.tar.gz: 78f0c3f6adb6c673b841dffb3e6743ac44042de833b8bf7e7bb1a75132e827a8
+  metadata.gz: d278dc09081dc277006eddb173fa17baf7016199c6bd87807ac00092c77ecece
+  data.tar.gz: 69933ba0ec72a9aeed28659e7547951d126f463b6b764200ba8e08e50af03b31
 SHA512:
-  metadata.gz: 17a190189ef3f1fb0487ba312796067c4fc91599452698eb7cb390fc1c928e14f9c5dce0b81d3107dd3c56c2af1fcbd4336c949db896b7d680b74f71dd65ed61
-  data.tar.gz: b7d8033d7265d4719a60b455b9635047ca0adbdf72eacb96445a7a92960a88608ac0375ebe3d2481075a1cc7bb65417db5869becbbf43882817728c3146b3a54
+  metadata.gz: 9f109ddf121b047b20fbd26388dc7bdd10f5b32f4845fe6a0474d7607171f248ae24b77c05270cd642793c5ef96f4407cdbb2b76637000aababc4432bab618b1
+  data.tar.gz: 956e6524daf79f6eacefb7237b4eb84e91b4cb4ed99dc2785b51bf65b1a168f24171704a677146aebf26d92eb4f6d118a55e8b2fe263171d67239bf25bf497f8

data/CHANGELOG.md

@@ -2,18 +2,25 @@
 
 All notable changes to this gem will be documented in this file.
 
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this gem adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
-## [0.1.0] - 2026-03-21
+## [0.1.2] - 2026-03-22
+
+### Fixed
+
+- Fix CHANGELOG header wording
+- Add bug_tracker_uri to gemspec
+
+## [0.1.0] - 2026-03-22
 
 ### Added
-- Initial release
-- `Bar` class with percentage, ETA, throughput, and customizable format
-- `Spinner` class with multiple frame sets (default, braille, dots)
-- `Multi` class for tracking multiple concurrent progress bars
-- Convenience methods `Progress.bar`, `Progress.spin`, `Progress.multi`
-- `Enumerable#each_with_progress` integration
+
+- `Bar` class with percentage, ETA, throughput, and progress visualization
+- `Spinner` class with braille frame animation
+- `Progress.bar` convenience method with block support and auto-finish
+- `Progress.spin` convenience method with block support
+- `Progress.each` for iterating enumerables with progress display
 - TTY detection to auto-disable rendering in non-terminal environments

data/README.md

@@ -1,10 +1,9 @@
 # philiprehberger-progress
 
-[![Tests](https://github.com/philiprehberger/rb-progress/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/rb-progress/actions/workflows/ci.yml)
-[![Gem Version](https://badge.fury.io/rb/philiprehberger-progress.svg)](https://rubygems.org/gems/philiprehberger-progress)
-[![License](https://img.shields.io/github/license/philiprehberger/rb-progress)](LICENSE)
+[![Gem Version](https://badge.fury.io/rb/philiprehberger-progress.svg)](https://badge.fury.io/rb/philiprehberger-progress)
+[![CI](https://github.com/philiprehberger/rb-progress/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/rb-progress/actions/workflows/ci.yml)
 
-Terminal progress bars and spinners with ETA calculation and throughput display
+Terminal progress bars and spinners with ETA calculation and throughput display.
 
 ## Requirements
 
@@ -12,16 +11,14 @@ Terminal progress bars and spinners with ETA calculation and throughput display
 
 ## Installation
 
-Add to your Gemfile:
-
-```ruby
-gem 'philiprehberger-progress'
+```sh
+gem install philiprehberger-progress
 ```
 
-Or install directly:
+Or add to your Gemfile:
 
-```bash
-gem install philiprehberger-progress
+```ruby
+gem 'philiprehberger-progress'
 ```
 
 ## Usage
@@ -31,110 +28,94 @@ gem install philiprehberger-progress
 ```ruby
 require 'philiprehberger/progress'
 
-Philiprehberger::Progress.bar(total: 100) do |bar|
-  100.times do
-    sleep(0.01)
-    bar.advance
-  end
+bar = Philiprehberger::Progress::Bar.new(total: 100)
+100.times do
+  sleep(0.01)
+  bar.advance
 end
+bar.finish
+# [████████████████████████████████] 100.0% | 100/100 | ETA: 0s | 100.0/s
 ```
 
-### Custom Format
+### Block Usage
 
 ```ruby
-bar = Philiprehberger::Progress::Bar.new(
-  total: 100,
-  format: ':bar :percent | :current/:total | :rate items/s | ETA: :eta',
-  width: 30
-)
-bar.advance(50)
-puts bar.to_s
+Philiprehberger::Progress.bar(total: 100) do |bar|
+  100.times { bar.advance }
+end
+# Auto-finishes when block completes
 ```
 
 ### Spinner
 
 ```ruby
-Philiprehberger::Progress.spin('Loading...') do |spinner|
-  10.times do
-    sleep(0.1)
-    spinner.spin
-  end
+spinner = Philiprehberger::Progress::Spinner.new(message: 'Loading...')
+10.times do
+  sleep(0.1)
+  spinner.spin
 end
+spinner.stop('done')
 ```
 
-### Enumerable Integration
+### Block Spinner
 
 ```ruby
-items = (1..100).to_a
-items.each_with_progress('Processing') do |item|
-  sleep(0.01)
+Philiprehberger::Progress.spin('Processing...') do |spinner|
+  10.times { spinner.spin; sleep(0.1) }
 end
 ```
 
-### Multi-Bar
+### Enumerable Integration
 
 ```ruby
-multi = Philiprehberger::Progress.multi
-bar1 = multi.bar('Downloads', total: 100)
-bar2 = multi.bar('Uploads', total: 50)
-
-bar1.advance(10)
-bar2.advance(5)
-multi.render
+items = (1..100).to_a
+Philiprehberger::Progress.each(items) do |item|
+  sleep(0.01)
+end
 ```
 
 ## API
 
-### `Philiprehberger::Progress`
-
-| Method | Description |
-|--------|-------------|
-| `.bar(total:, format:, width:)` | Create a progress bar (yields if block given) |
-| `.spin(message, frames:)` | Create a spinner (yields if block given) |
-| `.multi` | Create a multi-bar display |
-
 ### `Philiprehberger::Progress::Bar`
 
 | Method | Description |
 |--------|-------------|
-| `.new(total:, format:, width:)` | Create a progress bar |
-| `#advance(n)` | Advance by `n` items (default: 1) |
+| `.new(total:, width: 30, output: $stderr)` | Create a progress bar |
+| `#advance(n = 1)` | Advance by `n` items |
 | `#finish` | Mark as complete |
 | `#finished?` | Whether the bar is finished |
 | `#percentage` | Current percentage (0.0 to 100.0) |
 | `#elapsed` | Elapsed time in seconds |
 | `#eta` | Estimated time remaining in seconds |
-| `#rate` | Throughput in items per second |
+| `#throughput` | Items per second |
 | `#to_s` | Render the bar as a string |
 
 ### `Philiprehberger::Progress::Spinner`
 
 | Method | Description |
 |--------|-------------|
-| `.new(message:, frames:)` | Create a spinner |
+| `.new(message:, output: $stderr)` | Create a spinner |
 | `#spin` | Advance to the next frame |
-| `#done(message)` | Mark as done with optional message |
-| `#done?` | Whether the spinner is done |
-| `#to_s` | Render the current frame |
+| `#stop(final_message = 'done')` | Stop with a message |
+| `#stopped?` | Whether the spinner is stopped |
+| `#to_s` | Render the current frame with message |
 
-### `Philiprehberger::Progress::Multi`
+### Module Methods
 
 | Method | Description |
 |--------|-------------|
-| `.new` | Create a multi-bar display |
-| `#bar(label, total:)` | Add a new progress bar |
-| `#render` | Render all bars |
-| `#size` | Number of bars |
-| `#finished?` | Whether all bars are finished |
+| `Progress.bar(total:, &block)` | Create bar, auto-finish after block |
+| `Progress.spin(message, &block)` | Create spinner, auto-stop after block |
+| `Progress.each(enumerable, label: nil) { \|item\| }` | Iterate with progress |
 
 ## Development
 
-```bash
+```sh
 bundle install
-bundle exec rspec      # Run tests
-bundle exec rubocop    # Check code style
+bundle exec rspec
+bundle exec rubocop
 ```
 
 ## License
 
-MIT
+MIT License. See [LICENSE](LICENSE) for details.

data/lib/philiprehberger/progress/bar.rb

@@ -2,29 +2,14 @@
 
 module Philiprehberger
   module Progress
-    # A terminal progress bar with ETA and throughput display
-    #
-    # @example
-    #   bar = Bar.new(total: 100)
-    #   100.times { bar.advance }
-    #   bar.finish
     class Bar
-      DEFAULT_FORMAT = ':bar :percent | :current/:total | :rate items/s | ETA: :eta'
-      DEFAULT_WIDTH = 30
       FILL_CHAR = "\u2588"
       EMPTY_CHAR = "\u2591"
 
       attr_reader :current, :total
 
-      # Create a new progress bar
-      #
-      # @param total [Integer] total number of items
-      # @param format [String] format string with placeholders
-      # @param width [Integer] width of the bar portion in characters
-      # @param output [IO] output stream (default: $stderr)
-      def initialize(total:, format: DEFAULT_FORMAT, width: DEFAULT_WIDTH, output: $stderr)
+      def initialize(total:, width: 30, output: $stderr)
         @total = [total, 0].max
-        @format = format
         @width = width
         @output = output
         @current = 0
@@ -32,87 +17,59 @@ module Philiprehberger
         @finished = false
       end
 
-      # Advance the progress bar
-      #
-      # @param n [Integer] number of items to advance (default: 1)
-      # @return [self]
       def advance(n = 1)
         return self if @finished
 
         @current = [@current + n, @total].min
-        render if tty?
+        render_to_output
         self
       end
 
-      # Mark the progress as complete
-      #
-      # @return [self]
       def finish
         @current = @total
         @finished = true
-        render if tty?
+        render_to_output
         @output.write("\n") if tty?
         self
       end
 
-      # Check if the progress is finished
-      #
-      # @return [Boolean]
       def finished?
         @finished
       end
 
-      # Get the progress percentage
-      #
-      # @return [Float] percentage from 0.0 to 100.0
       def percentage
         return 100.0 if @total.zero?
 
         (@current.to_f / @total * 100).round(1)
       end
 
-      # Get the elapsed time in seconds
-      #
-      # @return [Float]
       def elapsed
         now - @start_time
       end
 
-      # Get the estimated time remaining in seconds
-      #
-      # @return [Float, nil] nil if no progress has been made
       def eta
         return 0.0 if @current >= @total
         return nil if @current.zero?
 
         elapsed_time = elapsed
-        rate = @current.to_f / elapsed_time
-        (@total - @current) / rate
+        items_per_sec = @current.to_f / elapsed_time
+        (@total - @current) / items_per_sec
       end
 
-      # Get the throughput in items per second
-      #
-      # @return [Float]
-      def rate
+      def throughput
         elapsed_time = elapsed
         return 0.0 if elapsed_time.zero?
 
         @current.to_f / elapsed_time
       end
 
-      # Render the progress bar as a string
-      #
-      # @return [String]
       def to_s
-        result = @format.dup
-        result.gsub!(':bar', render_bar)
-        result.gsub!(':percent', format('%<pct>5.1f%%', pct: percentage))
-        result.gsub!(':current', @current.to_s)
-        result.gsub!(':total', @total.to_s)
-        result.gsub!(':rate', format('%<r>.1f', r: rate))
-        result.gsub!(':eta', format_duration(eta))
-        result.gsub!(':elapsed', format_duration(elapsed))
-        result
+        bar_str = render_bar
+        pct = format('%<p>5.1f%%', p: percentage)
+        eta_str = format_eta(eta)
+        tput = format('%<t>.1f/s', t: throughput)
+
+        "[#{bar_str}] #{pct} | #{@current}/#{@total} | ETA: #{eta_str} | #{tput}"
       end
 
       private
@@ -125,8 +82,8 @@ module Philiprehberger
         @output.respond_to?(:tty?) && @output.tty?
       end
 
-      def render
-        @output.write("\r#{self}")
+      def render_to_output
+        @output.write("\r#{self}") if tty?
       end
 
       def render_bar
@@ -137,16 +94,18 @@ module Philiprehberger
         (FILL_CHAR * filled) + (EMPTY_CHAR * empty)
       end
 
-      def format_duration(seconds)
-        return '--:--' if seconds.nil? || seconds.negative?
+      def format_eta(seconds)
+        return '--:--' if seconds.nil?
+
+        secs = seconds.to_i
+        return '0s' if secs <= 0
 
-        seconds = seconds.to_i
-        if seconds < 60
-          format('0:%02d', seconds)
-        elsif seconds < 3600
-          format('%d:%02d', seconds / 60, seconds % 60)
+        if secs < 60
+          "#{secs}s"
+        elsif secs < 3600
+          format('%dm%02ds', secs / 60, secs % 60)
         else
-          format('%d:%02d:%02d', seconds / 3600, (seconds % 3600) / 60, seconds % 60)
+          format('%dh%02dm%02ds', secs / 3600, (secs % 3600) / 60, secs % 60)
         end
       end
     end

data/lib/philiprehberger/progress/multi.rb

@@ -1,70 +1,3 @@
 # frozen_string_literal: true
 
-module Philiprehberger
-  module Progress
-    # Multi-bar progress display for tracking multiple concurrent tasks
-    #
-    # @example
-    #   multi = Multi.new
-    #   bar1 = multi.bar('Downloads', total: 100)
-    #   bar2 = multi.bar('Uploads', total: 50)
-    class Multi
-      # Create a new multi-bar display
-      #
-      # @param output [IO] output stream (default: $stderr)
-      def initialize(output: $stderr)
-        @output = output
-        @bars = []
-      end
-
-      # Add a new progress bar
-      #
-      # @param label [String] label for the bar
-      # @param total [Integer] total items
-      # @param format [String] format string
-      # @param width [Integer] bar width
-      # @return [Bar]
-      def bar(label, total:, format: nil, width: 20)
-        bar_format = format || ":bar :percent | #{label}"
-        progress_bar = Bar.new(total: total, format: bar_format, width: width, output: StringIO.new)
-        @bars << { label: label, bar: progress_bar }
-        progress_bar
-      end
-
-      # Render all bars
-      #
-      # @return [self]
-      def render
-        return self unless tty?
-
-        # Move cursor up to overwrite previous render
-        @output.write("\e[#{@bars.length}A") if @rendered_once
-        @bars.each do |entry|
-          @output.write("\r\e[2K#{entry[:bar]}\n")
-        end
-        @rendered_once = true
-        self
-      end
-
-      # Number of bars being tracked
-      #
-      # @return [Integer]
-      def size
-        @bars.length
-      end
-
-      # Check if all bars are finished
-      #
-      # @return [Boolean]
-      def finished?
-        @bars.all? { |entry| entry[:bar].finished? }
-      end
-
-      private
-
-      def tty?
-        @output.respond_to?(:tty?) && @output.tty?
-      end
-    end
-  end
-end
+# This file is kept for backward compatibility but is no longer actively used.

data/lib/philiprehberger/progress/spinner.rb

@@ -2,73 +2,43 @@
 
 module Philiprehberger
   module Progress
-    # A terminal spinner for indeterminate progress
-    #
-    # @example
-    #   spinner = Spinner.new(message: 'Loading...')
-    #   spinner.spin
-    #   spinner.done
     class Spinner
-      DEFAULT_FRAMES = %w[| / - \\].freeze
-      BRAILLE_FRAMES = %W[\u2807 \u2816 \u2830 \u2821 \u280B \u2819 \u2838 \u2824].freeze
-      DOTS_FRAMES = %W[\u2800 \u2801 \u2803 \u2807 \u280F \u281F \u283F \u287F \u28FF].freeze
+      FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807",
+                "\u280F"].freeze
 
-      FRAME_SETS = {
-        default: DEFAULT_FRAMES,
-        braille: BRAILLE_FRAMES,
-        dots: DOTS_FRAMES
-      }.freeze
+      attr_reader :message
 
-      # Create a new spinner
-      #
-      # @param message [String] message to display next to the spinner
-      # @param frames [Symbol, Array<String>] frame set name or custom frames
-      # @param output [IO] output stream (default: $stderr)
-      def initialize(message: '', frames: :default, output: $stderr)
+      def initialize(message:, output: $stderr)
         @message = message
-        @frames = frames.is_a?(Symbol) ? FRAME_SETS.fetch(frames, DEFAULT_FRAMES) : frames
         @output = output
         @index = 0
-        @done = false
+        @stopped = false
       end
 
-      # Advance the spinner by one frame
-      #
-      # @return [self]
       def spin
-        return self if @done
+        return self if @stopped
 
-        render if tty?
-        @index = (@index + 1) % @frames.length
+        render_to_output
+        @index = (@index + 1) % FRAMES.length
         self
       end
 
-      # Mark the spinner as done
-      #
-      # @param message [String] optional completion message
-      # @return [self]
-      def done(message = nil)
-        @done = true
-        if tty?
-          clear_line
-          @output.write("#{message || @message}\n") if message || !@message.empty?
-        end
+      def stop(final_message = 'done')
+        @stopped = true
+        @output.write("\r\e[2K#{final_message}\n") if tty?
         self
       end
 
-      # Check if the spinner is done
-      #
-      # @return [Boolean]
-      def done?
-        @done
+      def stopped?
+        @stopped
+      end
+
+      def current_frame
+        FRAMES[@index % FRAMES.length]
       end
 
-      # Return the current frame
-      #
-      # @return [String]
       def to_s
-        frame = @frames[@index % @frames.length]
-        @message.empty? ? frame : "#{frame} #{@message}"
+        "#{current_frame} #{@message}"
       end
 
       private
@@ -77,12 +47,8 @@ module Philiprehberger
         @output.respond_to?(:tty?) && @output.tty?
       end
 
-      def render
-        @output.write("\r#{self}")
-      end
-
-      def clear_line
-        @output.write("\r\e[2K")
+      def render_to_output
+        @output.write("\r#{self}") if tty?
       end
     end
   end

data/lib/philiprehberger/progress/version.rb

@@ -2,6 +2,6 @@
 
 module Philiprehberger
   module Progress
-    VERSION = '0.1.0'
+    VERSION = '0.1.2'
   end
 end

data/lib/philiprehberger/progress.rb

@@ -1,27 +1,15 @@
 # frozen_string_literal: true
 
-require 'stringio'
 require_relative 'progress/version'
 require_relative 'progress/bar'
 require_relative 'progress/spinner'
-require_relative 'progress/multi'
 
 module Philiprehberger
   module Progress
-    class Error < StandardError; end
+    def self.bar(total:, width: 30, output: $stderr)
+      progress_bar = Bar.new(total: total, width: width, output: output)
 
-    # Create and yield a progress bar
-    #
-    # @param total [Integer] total number of items
-    # @param format [String] format string
-    # @param width [Integer] bar width
-    # @param output [IO] output stream
-    # @yield [Bar] the progress bar
-    # @return [Object] the block's return value
-    def self.bar(total:, format: Bar::DEFAULT_FORMAT, width: Bar::DEFAULT_WIDTH, output: $stderr, &block)
-      progress_bar = Bar.new(total: total, format: format, width: width, output: output)
-
-      if block
+      if block_given?
         result = yield progress_bar
         progress_bar.finish unless progress_bar.finished?
         result
@@ -30,57 +18,29 @@ module Philiprehberger
       end
     end
 
-    # Create and yield a spinner
-    #
-    # @param message [String] message to display
-    # @param frames [Symbol, Array<String>] frame set
-    # @param output [IO] output stream
-    # @yield the work to perform
-    # @return [Object] the block's return value
-    def self.spin(message = 'Loading...', frames: :default, output: $stderr, &block)
-      spinner = Spinner.new(message: message, frames: frames, output: output)
+    def self.spin(message, output: $stderr)
+      spinner = Spinner.new(message: message, output: output)
 
-      if block
+      if block_given?
         result = yield spinner
-        spinner.done unless spinner.done?
+        spinner.stop unless spinner.stopped?
         result
       else
         spinner
       end
     end
 
-    # Create a multi-bar display
-    #
-    # @param output [IO] output stream
-    # @return [Multi]
-    def self.multi(output: $stderr)
-      Multi.new(output: output)
-    end
-  end
-end
+    def self.each(enumerable, label: nil, output: $stderr)
+      items = enumerable.to_a
+      bar = Bar.new(total: items.length, output: output)
 
-# Enumerable integration
-module Enumerable
-  # Iterate with a progress bar
-  #
-  # @param message [String] label for the progress bar
-  # @param output [IO] output stream
-  # @yield [Object] each element
-  # @return [Array]
-  def each_with_progress(message = 'Processing', output: $stderr)
-    items = to_a
-    bar = Philiprehberger::Progress::Bar.new(
-      total: items.length,
-      format: ":bar :percent | #{message} | :current/:total",
-      output: output
-    )
+      items.each do |item|
+        yield item
+        bar.advance
+      end
 
-    items.each do |item|
-      yield item
-      bar.advance
+      bar.finish
+      items
     end
-
-    bar.finish
-    items
   end
 end

metadata

@@ -1,20 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-progress
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
-- Philip Rehberger
+- philiprehberger
 autorequire:
 bindir: bin
 cert_chain: []
 date: 2026-03-22 00:00:00.000000000 Z
 dependencies: []
 description: Display progress bars with percentage, ETA, and throughput, or spinners
-  for indeterminate tasks. Supports multi-bar display, Enumerable integration, and
-  auto-disables when not connected to a terminal.
+  for indeterminate tasks. Supports block-based usage, enumerable iteration, and auto-disables
+  rendering when not connected to a terminal.
 email:
-- me@philiprehberger.com
+- philiprehberger@users.noreply.github.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -44,7 +44,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="