chikari_palindrome 0.1.0

data/vendor/cache/ruby/2.7.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/output.rb

@@ -0,0 +1,68 @@
+class   ProgressBar
+class   Output
+  DEFAULT_OUTPUT_STREAM = $stdout
+
+  attr_accessor :stream
+
+  def initialize(options = {})
+    self.bar               = options[:bar]
+    self.stream            = options[:output] || DEFAULT_OUTPUT_STREAM
+    self.throttle          = Throttle.new(options)
+    self.length_calculator = Calculators::Length.new(
+                               :length => options[:length],
+                               :output => stream
+                             )
+  end
+
+  def self.detect(options = {})
+    if options[:output].is_a?(Class) && options[:output] <= ProgressBar::Output
+      options[:output].new(options)
+    elsif (options[:output] || DEFAULT_OUTPUT_STREAM).tty?
+      Outputs::Tty.new(options)
+    else
+      Outputs::NonTty.new(options)
+    end
+  end
+
+  def log(string)
+    clear
+    stream.puts string
+
+    refresh(:force => true) unless bar.stopped?
+  end
+
+  def clear_string
+    ' ' * length_calculator.length
+  end
+
+  def length
+    length_calculator.length
+  end
+
+  def with_refresh
+    yield
+    refresh
+  end
+
+  def refresh(options = {})
+    throttle.choke(:force_update_if => (bar.stopped? || options[:force])) do
+      clear if length_calculator.length_changed?
+
+      print_and_flush
+    end
+  end
+
+  protected
+
+  attr_accessor :length_calculator,
+                :throttle,
+                :bar
+
+  private
+
+  def print_and_flush
+    stream.print bar_update_string + eol
+    stream.flush
+  end
+end
+end

data/vendor/cache/ruby/2.7.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/outputs/non_tty.rb

@@ -0,0 +1,47 @@
+require 'ruby-progressbar/output'
+
+class   ProgressBar
+module  Outputs
+class   NonTty < Output
+  DEFAULT_FORMAT_STRING = '%t: |%b|'.freeze
+
+  def clear
+    self.last_update_length = 0
+
+    stream.print "\n"
+  end
+
+  def last_update_length
+    @last_update_length ||= 0
+  end
+
+  def bar_update_string
+    formatted_string        = bar.to_s
+    formatted_string        = formatted_string[0...-1] unless bar.finished?
+
+    output_string           = formatted_string[last_update_length..-1]
+    self.last_update_length = formatted_string.length
+
+    output_string.to_s
+  end
+
+  def default_format
+    DEFAULT_FORMAT_STRING
+  end
+
+  def resolve_format(*)
+    default_format
+  end
+
+  def refresh_with_format_change(*); end
+
+  def eol
+    bar.stopped? ? "\n" : ''
+  end
+
+  protected
+
+  attr_writer :last_update_length
+end
+end
+end

data/vendor/cache/ruby/2.7.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/outputs/null.rb

@@ -0,0 +1,33 @@
+require 'ruby-progressbar/output'
+
+class   ProgressBar
+module  Outputs
+class   Null < Output
+  alias refresh_with_format_change with_refresh
+
+  def clear;        end
+  def log(_string); end
+  def refresh(*);   end
+
+  def clear_string
+    ''
+  end
+
+  def bar_update_string
+    ''
+  end
+
+  def default_format
+    ''
+  end
+
+  def resolve_format(_format)
+    ''
+  end
+
+  def eol
+    ''
+  end
+end
+end
+end

data/vendor/cache/ruby/2.7.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/outputs/tty.rb

@@ -0,0 +1,32 @@
+require 'ruby-progressbar/output'
+
+class   ProgressBar
+module  Outputs
+class   Tty < Output
+  DEFAULT_FORMAT_STRING = '%t: |%B|'.freeze
+
+  alias refresh_with_format_change with_refresh
+
+  def clear
+    stream.print clear_string
+    stream.print "\r"
+  end
+
+  def bar_update_string
+    bar.to_s
+  end
+
+  def default_format
+    DEFAULT_FORMAT_STRING
+  end
+
+  def resolve_format(other_format)
+    other_format || default_format
+  end
+
+  def eol
+    bar.stopped? ? "\n" : "\r"
+  end
+end
+end
+end

data/vendor/cache/ruby/2.7.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/progress.rb

@@ -0,0 +1,118 @@
+require 'ruby-progressbar/errors/invalid_progress_error'
+
+class   ProgressBar
+class   Progress
+  DEFAULT_TOTAL              = 100
+  DEFAULT_BEGINNING_POSITION = 0
+  DEFAULT_SMOOTHING          = 0.1
+
+  attr_reader               :total,
+                            :progress
+
+  attr_accessor             :starting_position,
+                            :running_average,
+                            :smoothing
+
+  def initialize(options = {})
+    self.total     = options.fetch(:total, DEFAULT_TOTAL)
+    self.smoothing = options[:smoothing] || DEFAULT_SMOOTHING
+
+    start :at => DEFAULT_BEGINNING_POSITION
+  end
+
+  def start(options = {})
+    self.running_average   = 0
+    self.progress          = \
+      self.starting_position = options[:at] || progress
+  end
+
+  def finish
+    self.progress = total unless unknown?
+  end
+
+  def finished?
+    @progress == @total
+  end
+
+  def increment
+    if progress == total
+      warn "WARNING: Your progress bar is currently at #{progress} out of #{total} " \
+           "and cannot be incremented. In v2.0.0 this will become a " \
+           "ProgressBar::InvalidProgressError."
+    end
+
+    self.progress += 1 unless progress == total
+  end
+
+  def decrement
+    if progress == 0
+      warn "WARNING: Your progress bar is currently at #{progress} out of #{total} " \
+           "and cannot be decremented. In v2.0.0 this will become a " \
+           "ProgressBar::InvalidProgressError."
+    end
+
+    self.progress -= 1 unless progress == 0
+  end
+
+  def reset
+    start :at => starting_position
+  end
+
+  def progress=(new_progress)
+    if total && new_progress > total
+      fail ProgressBar::InvalidProgressError,
+           "You can't set the item's current value to be greater than the total."
+    end
+
+    @progress = new_progress
+
+    self.running_average = Calculators::RunningAverage.calculate(running_average,
+                                                                 absolute,
+                                                                 smoothing)
+  end
+
+  def total=(new_total)
+    unless progress.nil? || new_total.nil? || new_total >= progress
+      fail ProgressBar::InvalidProgressError,
+           "You can't set the item's total value to less than the current progress."
+    end
+
+    @total = new_total
+  end
+
+  def percentage_completed
+    return 0   if total.nil?
+    return 100 if total == 0
+
+    # progress / total * 100
+    #
+    # Doing this way so we can avoid converting each
+    # number to a float and then back to an integer.
+    #
+    (progress * 100 / total).to_i
+  end
+
+  def none?
+    running_average.zero? || progress.zero?
+  end
+
+  def unknown?
+    progress.nil? || total.nil?
+  end
+
+  def total_with_unknown_indicator
+    total || '??'
+  end
+
+  def percentage_completed_with_precision
+    return 100.0  if total == 0
+    return 0.0    if total.nil?
+
+    '%5.2f' % [(progress * 100 / total.to_f * 100).floor / 100.0]
+  end
+
+  def absolute
+    progress - starting_position
+  end
+end
+end

data/vendor/cache/ruby/2.7.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/refinements.rb

@@ -0,0 +1 @@
+require 'ruby-progressbar/refinements/enumerator'

data/vendor/cache/ruby/2.7.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/refinements/enumerator.rb

@@ -0,0 +1,23 @@
+class  ProgressBar
+module Refinements
+module Enumerator
+refine ::Enumerator do
+  def with_progressbar(options = {}, &block)
+    chain = ::Enumerator.new do |yielder|
+      progress_bar = ProgressBar.create(options.merge(:starting_at => 0, :total => size))
+
+      each do |*args|
+        yielder.yield(*args).tap do
+          progress_bar.increment
+        end
+      end
+    end
+
+    return chain unless block_given?
+
+    chain.each(&block)
+  end
+end
+end
+end
+end

data/vendor/cache/ruby/2.7.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/throttle.rb

@@ -0,0 +1,25 @@
+class   ProgressBar
+class   Throttle
+  attr_accessor :rate,
+                :started_at,
+                :stopped_at,
+                :timer
+
+  def initialize(options = {})
+    self.rate       = options[:throttle_rate] || 0.01
+    self.started_at = nil
+    self.stopped_at = nil
+    self.timer      = options.fetch(:throttle_timer, Timer.new)
+  end
+
+  def choke(options = {})
+    return unless !timer.started?                        ||
+                  options.fetch(:force_update_if, false) ||
+                  timer.elapsed_seconds >= rate
+
+    timer.restart
+
+    yield
+  end
+end
+end

data/vendor/cache/ruby/2.7.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/time.rb

@@ -0,0 +1,32 @@
+# rubocop:disable Style/InlineComment
+class   ProgressBar
+class   Time
+  TIME_MOCKING_LIBRARY_METHODS = [
+                                   :__simple_stub__now,     # ActiveSupport
+                                   :now_without_mock_time,  # Timecop
+                                   :now_without_delorean,   # Delorean
+                                   :now                     # Unmocked
+                                 ].freeze
+
+  def initialize(time = ::Time)
+    self.time = time
+  end
+
+  def now
+    time.__send__(unmocked_time_method)
+  end
+
+  def unmocked_time_method
+    @unmocked_time_method ||= begin
+                                TIME_MOCKING_LIBRARY_METHODS.find do |method|
+                                  time.respond_to? method
+                                end
+                              end
+  end
+
+  protected
+
+  attr_accessor :time
+end
+end
+# rubocop:enable Style/InlineComment

data/vendor/cache/ruby/2.7.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/timer.rb

@@ -0,0 +1,72 @@
+require 'ruby-progressbar/time'
+
+class   ProgressBar
+class   Timer
+  attr_accessor :started_at,
+                :stopped_at
+
+  def initialize(options = {})
+    self.time = options[:time] || ::ProgressBar::Time.new
+  end
+
+  def start
+    self.started_at = stopped? ? time.now - (stopped_at - started_at) : time.now
+    self.stopped_at = nil
+  end
+
+  def stop
+    return unless started?
+
+    self.stopped_at = time.now
+  end
+
+  def pause
+    stop
+  end
+
+  def resume
+    start
+  end
+
+  def started?
+    started_at
+  end
+
+  def stopped?
+    stopped_at
+  end
+
+  def reset
+    self.started_at = nil
+    self.stopped_at = nil
+  end
+
+  def reset?
+    !started_at
+  end
+
+  def restart
+    reset
+    start
+  end
+
+  def elapsed_seconds
+    ((stopped_at || time.now) - started_at)
+  end
+
+  def elapsed_whole_seconds
+    elapsed_seconds.floor
+  end
+
+  def divide_seconds(seconds)
+    hours, seconds   = seconds.divmod(3600)
+    minutes, seconds = seconds.divmod(60)
+
+    [hours, minutes, seconds]
+  end
+
+  protected
+
+  attr_accessor :time
+end
+end