tty-progressbar 0.15.1 → 0.18.2

data/lib/tty/progressbar/configuration.rb

@@ -1,62 +1,156 @@
+# frozen_string_literal: true
+
+require_relative "formats"
+
 module TTY
   class ProgressBar
     class Configuration
+      include TTY::ProgressBar::Formats
 
+      # The total number of steps to completion
+      # @api public
       attr_reader :total
 
+      # The maximum width for the progress bar except all formatting tokens
+      # @api public
       attr_accessor :width
-      #attr_reader :width
-
-      attr_accessor :no_width
 
-      attr_accessor :incomplete
+      # The complete character in progress animation
+      # @api public
+      attr_reader :complete
 
-      attr_accessor :complete
+      # The incomplete character in progress animation
+      # @api public
+      attr_reader :incomplete
 
+      # The head character, defaults to complete
+      # @api public
       attr_accessor :head
 
-      attr_accessor :hide_cursor
+      # The unknown character for indeterminate progress animation
+      # @api public
+      attr_reader :unknown
 
-      attr_accessor :clear
+      # The amount of indentation before a progress animation
+      # @api private
+      attr_accessor :inset
 
+      # The preconfigured bar format name, defaults to :classic
+      # @api public
+      attr_accessor :bar_format
+
+      # The object that responds to print call, defaults to stderr
+      # @api public
       attr_accessor :output
 
+      # The frequency with which to display a progress bar per second
+      # @api public
       attr_accessor :frequency
 
+      # The time interval for sampling of speed measurement, defaults to 1 second
+      # @api public
       attr_accessor :interval
 
-      attr_accessor :inset
+      # Whether or not to hide the cursor, defaults to false
+      # @api public
+      attr_accessor :hide_cursor
+
+      # Whether or not to clear the progress line, defaults to false
+      # @api public
+      attr_accessor :clear
+
+      # Whether or not to replace head character with complete, defaults to false
+      # @api public
+      attr_accessor :clear_head
 
       def initialize(options)
         self.total   = options[:total] if options[:total]
-        @width   = options.fetch(:width) { total }
-        @no_width    = options.fetch(:no_width) { false }
-        @incomplete  = options.fetch(:incomplete) { ' ' }
-        @complete    = options.fetch(:complete) { '=' }
-        @head        = options.fetch(:head) { @complete || '=' }
-        @hide_cursor = options.fetch(:hide_cursor) { false }
-        @clear       = options.fetch(:clear) { false }
+        @width       = options.fetch(:width) { total }
+        @bar_format  = options.fetch(:bar_format, :classic)
+        self.incomplete = options.fetch(:incomplete) { fetch_char(@bar_format, :incomplete) }
+        self.complete = options.fetch(:complete) { fetch_char(@bar_format, :complete) }
+        self.unknown = options.fetch(:unknown) { fetch_char(@bar_format, :unknown) }
+        @head        = options.fetch(:head) { @complete || "=" }
+        @clear_head  = options.fetch(:clear_head, false)
+        @hide_cursor = options.fetch(:hide_cursor, false)
+        @clear       = options.fetch(:clear, false)
         @output      = options.fetch(:output) { $stderr }
-        @frequency   = options.fetch(:frequency) { 0 } # 0Hz
-        @interval    = options.fetch(:interval) { 1 } # 1 sec
-        @inset       = options.fetch(:inset) { 0 }
+        @frequency   = options.fetch(:frequency, 0) # 0Hz
+        @interval    = options.fetch(:interval, 1) # 1 sec
+        @inset       = options.fetch(:inset, 0)
       end
 
-      # def width=(value)
-      #   return if value.nil?
+      # Set complete character(s)
+      #
+      # @param [String] value
+      #
+      # @api public
+      def complete=(value)
+        raise_if_empty(:complete, value)
 
-      #   if value < ProgressBar.max_columns
-      #     @width = value
-      #   else
-      #     @width = ProgressBar.max_columns
-      #   end
-      # end
+        @complete = value
+      end
+
+      # Set incomplete character(s)
+      #
+      # @param [String] value
+      #
+      # @api public
+      def incomplete=(value)
+        raise_if_empty(:incomplete, value)
+
+        @incomplete = value
+      end
+
+      # Set unknown character(s)
+      #
+      # @param [String] value
+      #
+      # @api public
+      def unknown=(value)
+        raise_if_empty(:unknown, value)
+
+        @unknown = value
+      end
 
+      # Set total and adjust width if unset
+      #
+      # @param [Integer,nil] value
+      #
+      # @api public
       def total=(value)
-        fail ArgumentError unless value
         @total = value
         self.width = value if width.nil?
       end
+
+      private
+
+      # Find bar char by type name and property
+      #
+      # @param [Symbol] name
+      # @param [Symbol] property
+      #
+      # @api private
+      def fetch_char(name, property)
+        if FORMATS.key?(name)
+          FORMATS[name][property]
+        else
+          raise ArgumentError, "unsupported bar format: #{name.inspect}. " \
+                               "Available formats are: " \
+                               "#{FORMATS.keys.sort.map(&:inspect).join(', ')}"
+        end
+      end
+
+      # Check whether a parameter's value is empty or not
+      #
+      # @raise [ArgumentError]
+      #
+      # @api private
+      def raise_if_empty(name, value)
+        return value unless value.to_s.empty?
+
+        raise ArgumentError, "cannot provide an empty string for #{name.inspect}"
+      end
     end # Configuration
   end # ProgressBar
 end # TTY

data/lib/tty/progressbar/converter.rb

@@ -15,19 +15,21 @@ module TTY
       #
       # @api public
       def to_time(seconds)
+        days = (seconds / (24 * HOURSECONDS).to_f).floor
+        seconds -= days * 24 * HOURSECONDS
         hours = (seconds / HOURSECONDS.to_f).floor
         seconds -= hours * HOURSECONDS
         minutes = (seconds / 60).floor
         seconds -= minutes * 60
 
-        if hours > 99
-          sprintf('%dh', hours)
+        if days > 0 # over 24 hours switch to days
+          format("%dd%2dh%2dm", days, hours, minutes)
         elsif hours > 0
-          sprintf('%2dh%2dm', hours, minutes)
+          format("%2dh%2dm", hours, minutes)
         elsif minutes > 0
-          sprintf('%2dm%2ds', minutes, seconds)
+          format("%2dm%2ds", minutes, seconds)
         else
-          sprintf('%2ds', seconds)
+          format("%2ds", seconds)
         end
       end
       module_function :to_time
@@ -41,43 +43,38 @@ module TTY
       #   the formatted result
       #
       # @api public
-      def to_seconds(seconds, precision = nil)
+      def to_seconds(seconds, precision: nil)
         precision ||= (seconds < 1 && !seconds.zero?) ? 5 : 2
-        sprintf "%5.#{precision}f", seconds
+        format "%5.#{precision}f", seconds
       end
       module_function :to_seconds
 
-      BYTE_UNITS = %w(b kb mb gb tb pb eb).freeze
+      BYTE_UNITS = %w[b kb mb gb tb pb eb].freeze
 
       # Convert value to bytes
       #
       # @param [Numeric] value
       #   the value to convert to bytes
-      # @param [Hash[Symbol]] options
-      # @option [Integer] :decimals
+      # @param [Integer] decimals
       #   the number of decimals parts
-      # @option [String] :separator
+      # @param [String] separator
       #   the separator to use for thousands in a number
-      # @option [String] :unit_separator
+      # @param [String] unit_separator
       #   the separtor to use between number and unit
       #
       # @return [String]
       #
       # @api public
-      def to_bytes(value, options = {})
-        decimals       = options.fetch(:decimals) { 2 }
-        separator      = options.fetch(:separator) { '.' }
-        unit_separator = options.fetch(:unit_separator) { '' }
-
+      def to_bytes(value, decimals: 2, separator: ".", unit_separator: "")
         base    = 1024
         pattern = "%.#{decimals}f"
 
-        unit = BYTE_UNITS.find.with_index { |_, i| value < base ** (i + 1) }
+        unit = BYTE_UNITS.find.with_index { |_, i| value < base**(i + 1) }
 
         if value < base
           formatted_value = value.to_i.to_s
         else
-          value_to_size = value / (base ** BYTE_UNITS.index(unit)).to_f
+          value_to_size = value / (base**BYTE_UNITS.index(unit)).to_f
           formatted_value = format(pattern, value_to_size)
         end
 

data/lib/tty/progressbar/formats.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module TTY
+  class ProgressBar
+    module Formats
+      FORMATS = {
+        arrow: { # ▸▸▸▸▸▹▹▹▹▹
+          complete: "▸",
+          incomplete: "▹",
+          unknown: "◂▸"
+        },
+        asterisk: { # ✱✱✱✱✱✳✳✳✳✳
+          complete: "✱",
+          incomplete: "✳",
+          unknown: "✳✱✳"
+        },
+        blade: { # ▰▰▰▰▰▱▱▱▱▱
+          complete: "▰",
+          incomplete: "▱",
+          unknown: "▱▰▱"
+        },
+        block: { # █████░░░░░
+          complete: "█",
+          incomplete: "░",
+          unknown: "█"
+        },
+        box: { # ■■■■■□□□□□
+          complete: "■",
+          incomplete: "□",
+          unknown: "□■□"
+        },
+        bracket: { # ❭❭❭❭❭❭❭❭❭❭
+         complete: "❭",
+         incomplete: " ",
+         unknown: "❬=❭"
+        },
+        burger: { # ≡≡≡≡≡≡≡≡≡≡
+          complete: "≡",
+          incomplete: " ",
+          unknown: "<≡>"
+        },
+        button: { # ⦿⦿⦿⦿⦿⦾⦾⦾⦾⦾
+          complete: "⦿",
+          incomplete: "⦾",
+          unknown: "⦾⦿⦾"
+        },
+        chevron: { # ››››››››››
+          complete: "›",
+          incomplete: " ",
+          unknown: "‹=›"
+        },
+        circle: { # ●●●●●○○○○○
+          complete: "●",
+          incomplete: "○",
+          unknown: "○●○"
+        },
+        classic: { # ==========
+          complete: "=",
+          incomplete: " ",
+          unknown: "<=>"
+        },
+        crate: { # ▣▣▣▣▣⬚⬚⬚⬚⬚
+          complete: "▣",
+          incomplete: "⬚",
+          unknown: "⬚▣⬚"
+        },
+        diamond: { # ♦♦♦♦♦♢♢♢♢♢
+          complete: "♦",
+          incomplete: "♢",
+          unknown: "♢♦♢"
+        },
+        dot: { # ･･････････
+          complete: "･",
+          incomplete: " ",
+          unknown: "･･･"
+        },
+        heart: { # ♥♥♥♥♥♡♡♡♡♡
+          complete: "♥",
+          incomplete: "♡",
+          unknown: "♡♥♡"
+        },
+        rectangle: { # ▮▮▮▮▮▯▯▯▯▯
+          complete: "▮",
+          incomplete: "▯",
+          unknown: "▯▮▯"
+        },
+        square: { # ▪▪▪▪▪▫▫▫▫▫
+          complete: "▪",
+          incomplete: "▫",
+          unknown: "▫▪▫"
+        },
+        star: { # ★★★★★☆☆☆☆☆
+          complete: "★",
+          incomplete: "☆",
+          unknown: "☆★☆"
+        },
+        track: { # ▬▬▬▬▬═════
+          complete: "▬",
+          incomplete: "═",
+          unknown: "═▬═"
+        },
+        tread: { # ❱❱❱❱❱❱❱❱❱❱
+          complete: "❱",
+          incomplete: " ",
+          unknown: "❰=❱"
+        },
+        triangle: { # ▶▶▶▶▶▷▷▷▷▷
+          complete: "▶",
+          incomplete: "▷",
+          unknown: "◀▶"
+        },
+        wave: { # ~~~~~_____
+          complete: "~",
+          incomplete: "_",
+          unknown: "<~>"
+        }
+      }.freeze
+    end # Formats
+  end # ProgressBar
+end # TTY

data/lib/tty/progressbar/formatter.rb

@@ -1,48 +1,43 @@
 # frozen_string_literal: true
 
-require_relative 'pipeline'
-
-require_relative 'formatter/bar'
-require_relative 'formatter/current'
-require_relative 'formatter/current_byte'
-require_relative 'formatter/elapsed'
-require_relative 'formatter/estimated'
-require_relative 'formatter/percent'
-require_relative 'formatter/rate'
-require_relative 'formatter/byte_rate'
-require_relative 'formatter/mean_rate'
-require_relative 'formatter/mean_byte'
-require_relative 'formatter/total'
-require_relative 'formatter/total_byte'
-
 module TTY
   class ProgressBar
-    class Formatter
-      extend Forwardable
-
-      def_delegators :@pipeline, :decorate, :use
-
-      # @api private
-      def initialize(pipeline = nil)
-        @pipeline = pipeline || TTY::ProgressBar::Pipeline.new
+    class Formatter < ::Module
+      # A helper for declaring a matching token pattern
+      #
+      # @api public
+      def self.[](token_match)
+        new(token_match)
       end
 
-      # Prepare default pipeline formatters
+      # Initialize this module with token matching pattern
       #
-      # @api private
-      def load
-        @pipeline.use TTY::ProgressBar::CurrentFormatter
-        @pipeline.use TTY::ProgressBar::TotalFormatter
-        @pipeline.use TTY::ProgressBar::TotalByteFormatter
-        @pipeline.use TTY::ProgressBar::ElapsedFormatter
-        @pipeline.use TTY::ProgressBar::EstimatedFormatter
-        @pipeline.use TTY::ProgressBar::PercentFormatter
-        @pipeline.use TTY::ProgressBar::ByteFormatter
-        @pipeline.use TTY::ProgressBar::ByteRateFormatter
-        @pipeline.use TTY::ProgressBar::RateFormatter
-        @pipeline.use TTY::ProgressBar::MeanRateFormatter
-        @pipeline.use TTY::ProgressBar::MeanByteFormatter
-        @pipeline.use TTY::ProgressBar::BarFormatter
+      # @param [Regexp] token_match
+      #   the token matching pattern
+      #
+      # @api public
+      def initialize(token_match)
+        pattern = token_match
+
+        module_eval do
+          define_method(:initialize) do |progress|
+            @progress = progress
+          end
+
+          define_method(:matcher) { pattern }
+          define_method(:progress) { @progress }
+
+          # Determines whether this formatter is applied or not.
+          #
+          # @param [Object] value
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          define_method(:matches?) do |value|
+            !!(value.to_s =~ pattern)
+          end
+        end
       end
     end # Formatter
   end # ProgressBar