hirohig_palindrome 0.1.0

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/calculators/length.rb

@@ -0,0 +1,100 @@
+class   ProgressBar
+module  Calculators
+class   Length
+  attr_reader   :length_override
+  attr_accessor :current_length,
+                :output
+
+  def initialize(options = {})
+    self.length_override = options[:length]
+    self.output          = options[:output]
+    self.current_length  = nil
+  end
+
+  def length
+    current_length || reset_length
+  end
+
+  def length_changed?
+    previous_length     = current_length
+    self.current_length = calculate_length
+
+    previous_length != current_length
+  end
+
+  def calculate_length
+    length_override || terminal_width || 80
+  end
+
+  def reset_length
+    self.current_length = calculate_length
+  end
+
+  def length_override=(other)
+    @length_override ||= ENV['RUBY_PROGRESS_BAR_LENGTH'] || other
+    @length_override = @length_override.to_i if @length_override
+  end
+
+  private
+
+  # This code was copied and modified from Rake, available under MIT-LICENSE
+  # Copyright (c) 2003, 2004 Jim Weirich
+  # rubocop:disable Style/RescueStandardError
+  def terminal_width
+    return 80 unless unix?
+
+    result = dynamic_width
+    (result < 20) ? 80 : result
+  rescue
+    80
+  end
+  # rubocop:enable Style/RescueStandardError
+
+  # rubocop:disable Lint/DuplicateMethods
+  begin
+    require 'io/console'
+
+    def dynamic_width
+      if output && output.tty? && output.respond_to?(:winsize)
+        dynamic_width_via_output_stream_object
+      elsif IO.console
+        dynamic_width_via_io_object
+      else
+        dynamic_width_via_system_calls
+      end
+    end
+  rescue LoadError
+    def dynamic_width
+      dynamic_width_via_system_calls
+    end
+  end
+  # rubocop:enable Lint/DuplicateMethods
+
+  def dynamic_width_via_output_stream_object
+    _rows, columns = output.winsize
+    columns
+  end
+
+  def dynamic_width_via_io_object
+    _rows, columns = IO.console.winsize
+    columns
+  end
+
+  def dynamic_width_via_system_calls
+    dynamic_width_stty.nonzero? || dynamic_width_tput
+  end
+
+  def dynamic_width_stty
+    `stty size 2>/dev/null`.split[1].to_i
+  end
+
+  def dynamic_width_tput
+    `tput cols 2>/dev/null`.to_i
+  end
+
+  def unix?
+    RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
+  end
+end
+end
+end

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/calculators/running_average.rb

@@ -0,0 +1,9 @@
+class   ProgressBar
+module  Calculators
+class   RunningAverage
+  def self.calculate(current_average, new_value_to_average, smoothing_factor)
+    new_value_to_average * (1.0 - smoothing_factor) + current_average * smoothing_factor
+  end
+end
+end
+end

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/components/bar.rb

@@ -0,0 +1,102 @@
+###
+# UPA = Unknown Progress Animation
+#
+class   ProgressBar
+module  Components
+class   Bar
+  DEFAULT_PROGRESS_MARK  = '='.freeze
+  DEFAULT_REMAINDER_MARK = ' '.freeze
+  DEFAULT_UPA_STEPS      = ['=---', '-=--', '--=-', '---='].freeze
+
+  attr_accessor :progress_mark,
+                :remainder_mark,
+                :length,
+                :progress,
+                :upa_steps
+
+  def initialize(options = {})
+    self.upa_steps      = options[:unknown_progress_animation_steps] || DEFAULT_UPA_STEPS
+    self.progress_mark  = options[:progress_mark]  || DEFAULT_PROGRESS_MARK
+    self.remainder_mark = options[:remainder_mark] || DEFAULT_REMAINDER_MARK
+    self.progress       = options[:progress]
+    self.length         = options[:length]
+  end
+
+  def to_s(options = { :format => :standard })
+    if progress.unknown?
+      unknown_string
+    elsif options[:format] == :standard
+      "#{standard_complete_string}#{incomplete_string}"
+    elsif options[:format] == :integrated_percentage
+      "#{integrated_percentage_complete_string}#{incomplete_string}"
+    end
+  end
+
+  private
+
+  def integrated_percentage_complete_string
+    return standard_complete_string if completed_length < 5
+
+    " #{progress.percentage_completed} ".to_s.center(completed_length, progress_mark)
+  end
+
+  def standard_complete_string
+    progress_mark * completed_length
+  end
+
+  def incomplete_string
+    remainder_mark * (length - completed_length)
+  end
+
+  def bar(length)
+    self.length = length
+
+    standard_complete_string
+  end
+
+  def complete_bar(length)
+    self.length = length
+
+    to_s(:format => :standard)
+  end
+
+  def complete_bar_with_percentage(length)
+    self.length = length
+
+    to_s(:format => :integrated_percentage)
+  end
+
+  def unknown_string
+    unknown_frame_string = unknown_progress_frame * ((length / upa_steps.size) + 2)
+
+    unknown_frame_string[0, length]
+  end
+
+  def incomplete_space(length)
+    self.length = length
+
+    if progress.unknown?
+      unknown_string
+    else
+      incomplete_string
+    end
+  end
+
+  def bar_with_percentage(length)
+    self.length = length
+
+    integrated_percentage_complete_string
+  end
+
+  def completed_length
+    (length * progress.percentage_completed / 100).floor
+  end
+
+  def unknown_progress_frame
+    current_animation_step = progress.progress % upa_steps.size
+
+    upa_steps[current_animation_step]
+  end
+end
+end
+end

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/components/percentage.rb

@@ -0,0 +1,29 @@
+class   ProgressBar
+module  Components
+class   Percentage
+  attr_accessor :progress
+
+  def initialize(options = {})
+    self.progress = options[:progress]
+  end
+
+  private
+
+  def percentage
+    progress.percentage_completed
+  end
+
+  def justified_percentage
+    progress.percentage_completed.to_s.rjust(3)
+  end
+
+  def percentage_with_precision
+    progress.percentage_completed_with_precision
+  end
+
+  def justified_percentage_with_precision
+    progress.percentage_completed_with_precision.to_s.rjust(6)
+  end
+end
+end
+end

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/components/rate.rb

@@ -0,0 +1,43 @@
+class   ProgressBar
+module  Components
+class   Rate
+  attr_accessor :rate_scale,
+                :started_at,
+                :stopped_at,
+                :timer,
+                :progress
+
+  def initialize(options = {})
+    self.rate_scale = options[:rate_scale] || lambda { |x| x }
+    self.started_at = nil
+    self.stopped_at = nil
+    self.timer      = options[:timer]
+    self.progress   = options[:progress]
+  end
+
+  private
+
+  def rate_of_change(format_string = '%i')
+    return 0 unless elapsed_seconds > 0
+
+    format_string % scaled_rate
+  end
+
+  def rate_of_change_with_precision
+    rate_of_change('%.2f')
+  end
+
+  def scaled_rate
+    rate_scale.call(base_rate)
+  end
+
+  def base_rate
+    progress.absolute / elapsed_seconds
+  end
+
+  def elapsed_seconds
+    timer.elapsed_whole_seconds.to_f
+  end
+end
+end
+end

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/components/time.rb

@@ -0,0 +1,107 @@
+###
+# OOB = 'Out of Bounds'
+#
+class   ProgressBar
+module  Components
+class   Time
+  TIME_FORMAT            = '%02d:%02d:%02d'.freeze
+  OOB_TIME_FORMATS       = [:unknown, :friendly, nil].freeze
+  OOB_LIMIT_IN_HOURS     = 99
+  OOB_UNKNOWN_TIME_TEXT  = '??:??:??'.freeze
+  OOB_FRIENDLY_TIME_TEXT = '> 4 Days'.freeze
+  NO_TIME_ELAPSED_TEXT   = '--:--:--'.freeze
+  ESTIMATED_LABEL        = ' ETA'.freeze
+  ELAPSED_LABEL          = 'Time'.freeze
+
+  def initialize(options = {})
+    self.out_of_bounds_time_format = options[:out_of_bounds_time_format]
+    self.timer                     = options[:timer]
+    self.progress                  = options[:progress]
+  end
+
+  def estimated_with_label
+    "#{ESTIMATED_LABEL}: #{estimated}"
+  end
+
+  def elapsed_with_label
+    "#{ELAPSED_LABEL}: #{elapsed}"
+  end
+
+  protected
+
+  def estimated_with_no_oob
+    self.out_of_bounds_time_format = nil
+
+    estimated_with_elapsed_fallback
+  end
+
+  def estimated_with_unknown_oob
+    self.out_of_bounds_time_format = :unknown
+
+    estimated_with_elapsed_fallback
+  end
+
+  def estimated_with_friendly_oob
+    self.out_of_bounds_time_format = :friendly
+
+    estimated_with_elapsed_fallback
+  end
+
+  attr_reader   :out_of_bounds_time_format
+  attr_accessor :timer,
+                :progress
+
+  def out_of_bounds_time_format=(format)
+    unless OOB_TIME_FORMATS.include? format
+      fail 'Invalid Out Of Bounds time format.  Valid formats are ' +
+        OOB_TIME_FORMATS.inspect
+    end
+
+    @out_of_bounds_time_format = format
+  end
+
+  private
+
+  def estimated
+    memo_estimated_seconds_remaining = estimated_seconds_remaining
+
+    return OOB_UNKNOWN_TIME_TEXT unless memo_estimated_seconds_remaining
+
+    hours, minutes, seconds = timer.divide_seconds(memo_estimated_seconds_remaining)
+
+    if hours > OOB_LIMIT_IN_HOURS && out_of_bounds_time_format
+      out_of_bounds_time
+    else
+      TIME_FORMAT % [hours, minutes, seconds]
+    end
+  end
+
+  def elapsed
+    return NO_TIME_ELAPSED_TEXT unless timer.started?
+
+    hours, minutes, seconds = timer.divide_seconds(timer.elapsed_whole_seconds)
+
+    TIME_FORMAT % [hours, minutes, seconds]
+  end
+
+  def estimated_with_elapsed_fallback
+    progress.finished? ? elapsed_with_label : estimated_with_label
+  end
+
+  def estimated_seconds_remaining
+    return if progress.unknown? || progress.none? || timer.stopped?
+
+    (timer.elapsed_seconds * (progress.total / progress.running_average - 1)).round
+  end
+
+  def out_of_bounds_time
+    case out_of_bounds_time_format
+    when :unknown
+      OOB_UNKNOWN_TIME_TEXT
+    when :friendly
+      OOB_FRIENDLY_TIME_TEXT
+    end
+  end
+end
+end
+end

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/components/title.rb

@@ -0,0 +1,13 @@
+class   ProgressBar
+module  Components
+class   Title
+  DEFAULT_TITLE = 'Progress'.freeze
+
+  attr_accessor :title
+
+  def initialize(options = {})
+    self.title = options[:title] || DEFAULT_TITLE
+  end
+end
+end
+end

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/components.rb

@@ -0,0 +1,5 @@
+require 'ruby-progressbar/components/bar'
+require 'ruby-progressbar/components/percentage'
+require 'ruby-progressbar/components/rate'
+require 'ruby-progressbar/components/time'
+require 'ruby-progressbar/components/title'

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/errors/invalid_progress_error.rb

@@ -0,0 +1,4 @@
+class   ProgressBar
+class   InvalidProgressError < RuntimeError
+end
+end

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/format/formatter.rb

@@ -0,0 +1,27 @@
+class   ProgressBar
+module  Format
+class   Formatter
+  def self.process(format_string, max_length, bar)
+    processed_string = format_string.dup
+
+    format_string.non_bar_molecules.each do |molecule|
+      processed_string.gsub!(molecule.full_key, molecule.lookup_value(bar, nil))
+    end
+
+    processed_string.gsub!(/%%/, '%')
+
+    bar_length         = max_length -
+                         processed_string.displayable_length +
+                         format_string.bar_molecule_placeholder_length
+    bar_length         = (bar_length < 0) ? 0 : bar_length
+
+    format_string.bar_molecules.each do |molecule|
+      processed_string.gsub!(molecule.full_key,
+                             molecule.lookup_value(bar, bar_length))
+    end
+
+    processed_string
+  end
+end
+end
+end

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/format/molecule.rb

@@ -0,0 +1,60 @@
+class   ProgressBar
+module  Format
+class   Molecule
+  MOLECULES = {
+    :t => [:title_comp,   :title],
+    :T => [:title_comp,   :title],
+    :c => [:progressable, :progress],
+    :C => [:progressable, :total],
+    :u => [:progressable, :total_with_unknown_indicator],
+    :p => [:percentage,   :percentage],
+    :P => [:percentage,   :percentage_with_precision],
+    :j => [:percentage,   :justified_percentage],
+    :J => [:percentage,   :justified_percentage_with_precision],
+    :a => [:time,         :elapsed_with_label],
+    :e => [:time,         :estimated_with_unknown_oob],
+    :E => [:time,         :estimated_with_friendly_oob],
+    :f => [:time,         :estimated_with_no_oob],
+    :B => [:bar,          :complete_bar],
+    :b => [:bar,          :bar],
+    :W => [:bar,          :complete_bar_with_percentage],
+    :w => [:bar,          :bar_with_percentage],
+    :i => [:bar,          :incomplete_space],
+    :r => [:rate,         :rate_of_change],
+    :R => [:rate,         :rate_of_change_with_precision]
+  }.freeze
+
+  BAR_MOLECULES = %w{W w B b i}.freeze
+
+  attr_accessor :key,
+                :method_name
+
+  def initialize(letter)
+    self.key         = letter
+    self.method_name = MOLECULES.fetch(key.to_sym)
+  end
+
+  def bar_molecule?
+    BAR_MOLECULES.include? key
+  end
+
+  def non_bar_molecule?
+    !bar_molecule?
+  end
+
+  def full_key
+    "%#{key}"
+  end
+
+  def lookup_value(environment, length = 0)
+    component = environment.__send__(method_name[0])
+
+    if bar_molecule?
+      component.__send__(method_name[1], length).to_s
+    else
+      component.__send__(method_name[1]).to_s
+    end
+  end
+end
+end
+end

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/format/string.rb

@@ -0,0 +1,36 @@
+class   ProgressBar
+module  Format
+class   String < ::String
+  MOLECULE_PATTERN = /%[a-zA-Z]/.freeze
+  ANSI_SGR_PATTERN = /\e\[[\d;]+m/.freeze
+
+  def displayable_length
+    gsub(ANSI_SGR_PATTERN, '').length
+  end
+
+  def bar_molecule_placeholder_length
+    @bar_molecule_placeholder_length ||= bar_molecules.size * 2
+  end
+
+  def non_bar_molecules
+    @non_bar_molecules ||= molecules.select(&:non_bar_molecule?)
+  end
+
+  def bar_molecules
+    @bar_molecules ||= molecules.select(&:bar_molecule?)
+  end
+
+  def molecules
+    @molecules ||= begin
+                      molecules = []
+
+                      scan(MOLECULE_PATTERN) do |match|
+                        molecules << Molecule.new(match[1, 1])
+                      end
+
+                      molecules
+                    end
+  end
+end
+end
+end

data/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.10.1/lib/ruby-progressbar/format.rb

@@ -0,0 +1,3 @@
+require 'ruby-progressbar/format/molecule'
+require 'ruby-progressbar/format/formatter'
+require 'ruby-progressbar/format/string'

data/vendor/bundle/ruby/2.6.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/bundle/ruby/2.6.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/bundle/ruby/2.6.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