hirohig_palindrome 0.1.0

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/lib/ansi/diff.rb

@@ -0,0 +1,215 @@
+require 'ansi/code'
+
+module ANSI
+
+  # Diff produces colorized differences of two string or objects.
+  #
+  class Diff
+
+    # Highlights the differnce between two strings.
+    #
+    # This class method is equivalent to calling:
+    #
+    #   ANSI::Diff.new(object1, object2).to_a
+    #
+    def self.diff(object1, object2, options={})
+      new(object1, object2, options={}).to_a
+    end
+
+    # Setup new Diff object. If the objects given are not Strings
+    # and do not have `#to_str` defined to coerce them to such, then
+    # their `#inspect` methods are used to convert them to strings
+    # for comparison.
+    #
+    # @param [Object] object1
+    #   First object to compare.
+    #
+    # @param [Object] object2
+    #   Second object to compare.
+    #
+    # @param [Hash] options
+    #   Options for contoller the way difference is shown. (Not yet used.)
+    #
+    def initialize(object1, object2, options={})
+      @object1 = convert(object1)
+      @object2 = convert(object2)
+
+      @diff1, @diff2 = diff_string(@object1, @object2)
+    end
+
+    # Returns the first object's difference string.
+    def diff1
+      @diff1
+    end
+
+    # Returns the second object's difference string.
+    def diff2
+      @diff2
+    end
+
+    # Returns both first and second difference strings separated by a
+    # new line character.
+    #
+    # @todo Should we use `$/` record separator instead?
+    #
+    # @return [String] Joined difference strings.
+    def to_s
+      "#{@diff1}\n#{@diff2}"
+    end
+
+    # Returns both first and second difference strings separated by a
+    # the given `separator`. The default is `$/`, the record separator.
+    #
+    # @param [String] separator
+    #   The string to use as the separtor between the difference strings.
+    #
+    # @return [String] Joined difference strings.
+    def join(separator=$/)
+      "#{@diff1}#{separator}#{@diff2}"
+    end
+
+    # Returns the first and second difference strings in an array.
+    #
+    # @return [Array] Both difference strings.
+    def to_a
+      [diff1, diff2]
+    end
+
+  private
+
+    # Take two plain strings and produce colorized
+    # versions of each highlighting their differences.
+    #
+    # @param [String] string1
+    #   First string to compare.
+    #
+    # @param [String] string2
+    #   Second string to compare.
+    #
+    # @return [Array<String>] The two difference strings.
+    def diff_string(string1, string2)
+      compare(string1, string2)
+    end
+
+    # Ensure the object of comparison is a string. If +object+ is not
+    # an instance of String then it wll be converted to one by calling
+    # either #to_str, if the object responds to it, or #inspect.
+    def convert(object)
+      if String === object
+        object
+      elsif object.respond_to?(:to_str)
+        object.to_str
+      else
+        object.inspect
+      end
+    end
+
+    # Rotation of colors for diff output.
+    COLORS = [:red, :yellow, :magenta]
+
+    # Take two plain strings and produce colorized
+    # versions of each highlighting their differences.
+    #
+    # @param [String] x
+    #   First string to compare.
+    #
+    # @param [String] y
+    #   Second string to compare.
+    #
+    # @return [Array<String>] The two difference strings.
+    def compare(x, y)
+      c = common(x, y)
+      a = x.dup
+      b = y.dup
+      oi = 0
+      oj = 0
+      c.each_with_index do |m, q|
+        i = a.index(m, oi)
+        j = b.index(m, oj)
+        a[i,m.size] = ANSI.ansi(m, COLORS[q%3]) if i
+        b[j,m.size] = ANSI.ansi(m, COLORS[q%3]) if j
+        oi = i + m.size if i
+        oj = j + m.size if j
+      end
+      return a, b
+    end
+
+    # Oh, I should have documented this will I knew what the
+    # hell it was doing ;)
+    def common(x,y)
+      c = lcs(x, y)
+
+      i = x.index(c)
+      j = y.index(c)
+
+      ix = i + c.size
+      jx = j + c.size
+
+      if i == 0 
+        l = y[0...j]
+      elsif j == 0
+        l = x[0...i]
+      else
+        l = common(x[0...i], y[0...j])
+      end
+
+      if ix == x.size - 1
+        r = y[jx..-1]
+      elsif jx = y.size - 1
+        r = x[ix..-1]
+      else
+        r = common(x[ix..-1], y[jx..-1])
+      end
+
+      [l, c, r].flatten.reject{ |s| s.empty? }
+    end
+
+    # Least common string.
+    def lcs(s1, s2)
+      res="" 
+      num=Array.new(s1.size){Array.new(s2.size)}
+      len,ans=0
+      lastsub=0
+      s1.scan(/./).each_with_index do |l1,i |
+        s2.scan(/./).each_with_index do |l2,j |
+          unless l1==l2
+            num[i][j]=0
+          else
+            (i==0 || j==0)? num[i][j]=1 : num[i][j]=1 + num[i-1][j-1]
+            if num[i][j] > len
+              len = ans = num[i][j]
+              thissub = i
+              thissub -= num[i-1][j-1] unless num[i-1][j-1].nil?  
+              if lastsub==thissub
+                res+=s1[i,1]
+              else
+                lastsub=thissub
+                res=s1[lastsub, (i+1)-lastsub]
+              end
+            end
+          end
+        end
+      end
+      res
+    end
+
+    # Hmm... is this even useful?
+    def lcs_size(s1, s2)
+      num=Array.new(s1.size){Array.new(s2.size)}
+      len,ans=0,0
+      s1.scan(/./).each_with_index do |l1,i |
+        s2.scan(/./).each_with_index do |l2,j |
+          unless l1==l2
+            num[i][j]=0
+          else
+            (i==0 || j==0)? num[i][j]=1 : num[i][j]=1 + num[i-1][j-1]
+            len = ans = num[i][j] if num[i][j] > len
+          end
+        end
+      end
+      ans
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/lib/ansi/hexdump.rb

@@ -0,0 +1,122 @@
+module ANSI
+
+  require 'ansi/code'
+
+  # TODO: split dump method into two parts, the first should create a hex table
+  # then the second, #dump method, will print it out.
+
+  # Create a colorized hex dump of byte string.
+  # 
+  # Output looks something like the following, but colorized.
+  # 
+  #   000352c0:  ed 33 8c 85 6e cc f6 f7  72 79 1c e3 3a b4 c2 c6  |.3..n...ry..:...|
+  #   000352d0:  c8 8d d6 ee 3e 68 a1 a5  ae b2 b7 97 a4 1d 5f a7  |....>h........_.|
+  #   000352e0:  d8 7d 28 db f6 8a e7 8a  7b 8d 0b bd 35 7d 25 3c  |.}(.....{...5}%<|
+  #   000352f0:  8b 3c c8 9d ec 04 85 54  92 a0 f7 a8 ed cf 05 7d  |.<.....T.......}|
+  #   00035300:  b5 e3 9e 35 f0 79 9f 51  74 e3 60 ee 0f 03 8e 3f  |...5.y.Qt.`....?|
+  #   00035310:  05 5b 91 87 e6 48 48 ee  a3 77 ae ad 5e 2a 56 a2  |.[...HH..w..^*V.|
+  #   00035320:  b6 96 86 f3 3c 92 b3 c8  62 4a 6f 96 10 5c 9c bb  |....<...bJo..\..|
+  #
+  # In the future, we will make the colorization more customizable and
+  # allow the groupings to be selectable at 2, 4, 8 or 16.
+  #
+  class HexDump
+
+    # Printable ASCII codes.
+    ASCII_PRINTABLE = (33..126)
+
+    #
+    def initialize(options={})
+      @offset = 0
+
+      options.each do |k,v|
+        __send__("#{k}=", v)
+      end
+
+      @color = true if color.nil?
+    end
+
+    # Use color?
+    attr_accessor :color
+
+    # Show index?
+    attr_accessor :index
+
+    # Offset byte count.
+    attr_accessor :offset
+
+    # Dump data string as colorized hex table.
+    #
+    # @param data [String]
+    #   String to convert to hex and display.
+    #
+    def dump(data)
+      lines             = data.to_s.scan(/.{1,16}/m)
+      max_offset        = (offset + data.size) / 256  #16 * 16
+      max_offset_width  = max_offset.to_s.size + 1
+      max_hex_width     = 49  #3 * 16 + 1
+
+      out = template()
+      off = offset()
+
+      if index?
+        puts((' ' * max_offset_width) + "    0  1  2  3  4  5  6  7   8  9  A  B  C  D  E  F\n")
+      end
+
+      lines.each_with_index do |line, n|
+        offset = off + n * 16
+        bytes  = line.unpack("C*")
+        hex    = bytes.map{ |c| "%0.2x" % c }.insert(8, '').join(' ')
+
+        plain = bytes.map do |c|
+          if ASCII_PRINTABLE.include?(c)
+            c = c.chr
+          else
+            color ? Code::WHITE + Code::STRIKE + '.' + Code::CLEAR : '.' 
+          end
+        end.join('')
+
+        fill = [offset.to_s.rjust(max_offset_width), hex.ljust(max_hex_width), plain]
+
+        puts(out % fill)
+      end      
+    end
+
+    # Hex dump a random string.
+    #
+    def dump_random(size=64)
+      data = (0..size).map{ rand(255).chr }.join('')
+      dump(data)
+    end
+
+    #
+    def index?
+      @index
+    end
+
+  private
+
+    # Hex dump line template.
+    #
+    # @return [String] hex dump line template
+    def template
+      if color
+        Code::CYAN +
+        "%s:  " +
+        Code::YELLOW +
+        "%s " +
+        Code::BLUE +
+        "|" +
+        Code::CLEAR +
+        "%s" +
+        Code::BLUE +
+        "|" +
+        Code::CLEAR
+      else
+        "%s:  %s |%s|"
+      end
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/lib/ansi/logger.rb

@@ -0,0 +1,211 @@
+# Ansi::Logger
+# Copyright (c) 2009 Thomas Sawyer
+# Copyright (c) 2005 George Moschovitis
+
+require "logger"
+require "time"
+require "ansi/code"
+
+# = ANSI::Logger
+#
+# Extended variation of Ruby's standard Logger library that supports
+# color output.
+#
+#   log = ANSI::Logger.new
+#
+#   log.formatter do |severity, timestamp, progname, msg|
+#     ANSI::Logger::SIMPLE_FORMAT % [severity, msg]
+#   end
+#
+#--
+# TODO: What's all this about then?
+#
+# When using debug level logger messages always append 'if $DBG'
+# at the end. This hack is needed because Ruby does not support
+# lazy evaluation (lisp macros).
+#++
+class ANSI::Logger < Logger
+
+  # Some available logging formats.
+  SIMPLE_FORMAT   = "%5s: %s\n"
+  DETAILED_FORMAT = "%s %5s: %s\n"
+
+  # TODO: Not sure I like this approach.
+  class ::Logger #:nodoc:
+    class LogDevice #:nodoc:
+      attr_writer :ansicolor
+
+      def ansicolor?
+        @ansicolor.nil? ? true : @ansicolor
+      end
+    end
+  end
+
+  #
+  def ansicolor?
+    @logdev.ansicolor?
+  end
+
+  #
+  def ansicolor=(on)
+    @logdev.ansicolor = on
+  end
+
+  # Dictate the way in which this logger should format the
+  # messages it displays. This method requires a block. The
+  # block should return formatted strings given severity,
+  # timestamp, progname and msg.
+  #
+  # === Example
+  #
+  #   logger = ANSI::Logger.new
+  #
+  #   logger.formatter do |severity, timestamp, progname, msg|
+  #     "#{progname}@#{timestamp} - #{severity}::#{msg}"
+  #   end
+  #
+  def formatter(&block)
+    self.formatter = block if block
+    super
+  end
+
+  def styles(options=nil)
+    @styles ||= {
+      :info  => [],
+      :warn  => [:yellow],
+      :debug => [:cyan],
+      :error => [:red],
+      :fatal => [:bold, :red]
+    }
+    @styles.merge!(options) if options
+    @styles
+  end
+
+  #
+  def info(progname=nil, &block)
+    return unless info?
+    @logdev.ansicolor? ? info_with_color{ super } : super
+  end
+
+  #
+  def warn(progname=nil, &block)
+    return unless warn?
+    @logdev.ansicolor? ? warn_with_color{ super } : super
+  end
+
+  #
+  def debug(progname=nil, &block)
+    return unless debug?
+    @logdev.ansicolor? ? debug_with_color{ super } : super
+  end
+
+  #
+  def error(progname=nil, &block)
+    return unless error?
+    @logdev.ansicolor? ? error_with_color{ super } : super
+  end
+
+  #
+  def fatal(progname=nil, &block)
+    return unless error?
+    @logdev.ansicolor? ? fatal_with_color{ super } : super
+  end
+
+private
+
+  def info_with_color #:yield:
+    styles[:info].each{ |s| self << ANSI::Code.send(s) }
+    yield
+    self << ANSI::Code.clear
+  end
+
+  def warn_with_color #:yield:
+    styles[:warn].each{ |s| self << ANSI::Code.send(s) }
+    yield
+    self << ANSI::Code.clear
+  end
+
+  def error_with_color #:yield:
+    styles[:error].each{ |s| self << ANSI::Code.send(s) }
+    yield
+    self << ANSI::Code.clear
+  end
+
+  def debug_with_color #:yield:
+    styles[:debug].each{ |s| self << ANSI::Code.send(s) }
+    yield
+    self << ANSI::Code.clear
+  end
+
+  def fatal_with_color #:yield:
+    styles[:fatal].each{ |s| self << ANSI::Code.send(s) }
+    yield
+    self << ANSI::Code.clear
+  end
+
+end
+
+
+# NOTE: trace is deprecated b/c binding of caller is no longer possible.
+=begin
+  # Prints a trace message to DEBUGLOG (at debug level).
+  # Useful for emitting the value of variables, etc.  Use
+  # like this:
+  #
+  #   x = y = 5
+  #   trace 'x'        # -> 'x = 5'
+  #   trace 'x ** y'   # -> 'x ** y = 3125'
+  #
+  # If you have a more complicated value, like an array of
+  # hashes, then you'll probably want to use an alternative
+  # output format.  For instance:
+  #
+  #   trace 'value', :yaml
+  #
+  # Valid output format values (the _style_ parameter) are:
+  #
+  #   :p :inspect
+  #   :pp                     (pretty-print, using 'pp' library)
+  #   :s :to_s
+  #   :y :yaml :to_yaml       (using the 'yaml' library')
+  #
+  # The default is <tt>:p</tt>.
+  #
+  # CREDITS:
+  #
+  # This code comes straight from the dev-utils Gem.
+  # Author: Gavin Sinclair <gsinclair@soyabean.com.au>
+
+  def trace(expr, style=:p)
+    unless expr.respond_to? :to_str
+      warn "trace: Can't evaluate the given value: #{caller.first}"
+    else
+      raise "FACETS: binding/or_caller is no longer possible"
+      require "facets/core/binding/self/of_caller"
+
+      Binding.of_caller do |b|
+        value = b.eval(expr.to_str)
+        formatter = TRACE_STYLES[style] || :inspect
+        case formatter
+        when :pp then require 'pp'
+        when :y, :yaml, :to_yaml then require 'yaml'
+        end
+        value_s = value.send(formatter)
+        message = "#{expr} = #{value_s}"
+        lines = message.split(/\n/)
+        indent = "   "
+        debug(lines.shift)
+        lines.each do |line|
+          debug(indent + line)
+        end
+      end
+    end
+  end
+
+  TRACE_STYLES = {}  # :nodoc:
+  TRACE_STYLES.update(
+    :pp => :pp_s, :s => :to_s, :p => :inspect,
+    :y => :to_yaml, :yaml => :to_yaml,
+    :inspect => :inspect, :to_yaml => :to_yaml
+  )
+=end

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/lib/ansi/mixin.rb

@@ -0,0 +1,121 @@
+module ANSI
+  require 'ansi/code'
+
+  # This module is designed specifically for mixing into
+  # String-like classes or extending String-like objects.
+  #
+  # Generally speaking the String#ansi method is the more
+  # elegant approach to modifying a string with codes
+  # via a method call. But in some cases this Mixin's design
+  # might be preferable. Indeed, it original intent was
+  # as a compatability layer for the +colored+ gem.
+
+  module Mixin
+
+    def bold       ; ANSI::Code.bold       { to_s } ; end
+    def dark       ; ANSI::Code.dark       { to_s } ; end
+    def italic     ; ANSI::Code.italic     { to_s } ; end
+    def underline  ; ANSI::Code.underline  { to_s } ; end
+    def underscore ; ANSI::Code.underscore { to_s } ; end
+    def blink      ; ANSI::Code.blink      { to_s } ; end
+    def rapid      ; ANSI::Code.rapid      { to_s } ; end
+    def reverse    ; ANSI::Code.reverse    { to_s } ; end
+    def negative   ; ANSI::Code.negative   { to_s } ; end
+    def concealed  ; ANSI::Code.concealed  { to_s } ; end
+    def strike     ; ANSI::Code.strike     { to_s } ; end
+
+    def black      ; ANSI::Code.black      { to_s } ; end
+    def red        ; ANSI::Code.red        { to_s } ; end
+    def green      ; ANSI::Code.green      { to_s } ; end
+    def yellow     ; ANSI::Code.yellow     { to_s } ; end
+    def blue       ; ANSI::Code.blue       { to_s } ; end
+    def magenta    ; ANSI::Code.magenta    { to_s } ; end
+    def cyan       ; ANSI::Code.cyan       { to_s } ; end
+    def white      ; ANSI::Code.white      { to_s } ; end
+
+    def on_black   ; ANSI::Code.on_black   { to_s } ; end
+    def on_red     ; ANSI::Code.on_red     { to_s } ; end
+    def on_green   ; ANSI::Code.on_green   { to_s } ; end
+    def on_yellow  ; ANSI::Code.on_yellow  { to_s } ; end
+    def on_blue    ; ANSI::Code.on_blue    { to_s } ; end
+    def on_magenta ; ANSI::Code.on_magenta { to_s } ; end
+    def on_cyan    ; ANSI::Code.on_cyan    { to_s } ; end
+    def on_white   ; ANSI::Code.on_white   { to_s } ; end
+
+    def black_on_red      ; ANSI::Code.black_on_red      { to_s } ; end
+    def black_on_green    ; ANSI::Code.black_on_green    { to_s } ; end
+    def black_on_yellow   ; ANSI::Code.black_on_yellow   { to_s } ; end
+    def black_on_blue     ; ANSI::Code.black_on_blue     { to_s } ; end
+    def black_on_magenta  ; ANSI::Code.black_on_magenta  { to_s } ; end
+    def black_on_cyan     ; ANSI::Code.black_on_cyan     { to_s } ; end
+    def black_on_white    ; ANSI::Code.black_on_white    { to_s } ; end
+
+    def red_on_black      ; ANSI::Code.red_on_black      { to_s } ; end
+    def red_on_green      ; ANSI::Code.red_on_green      { to_s } ; end
+    def red_on_yellow     ; ANSI::Code.red_on_yellow     { to_s } ; end
+    def red_on_blue       ; ANSI::Code.red_on_blue       { to_s } ; end
+    def red_on_magenta    ; ANSI::Code.red_on_magenta    { to_s } ; end
+    def red_on_cyan       ; ANSI::Code.red_on_cyan       { to_s } ; end
+    def red_on_white      ; ANSI::Code.red_on_white      { to_s } ; end
+
+    def green_on_black    ; ANSI::Code.green_on_black    { to_s } ; end
+    def green_on_red      ; ANSI::Code.green_on_red      { to_s } ; end
+    def green_on_yellow   ; ANSI::Code.green_on_yellow   { to_s } ; end
+    def green_on_blue     ; ANSI::Code.green_on_blue     { to_s } ; end
+    def green_on_magenta  ; ANSI::Code.green_on_magenta  { to_s } ; end
+    def green_on_cyan     ; ANSI::Code.green_on_cyan     { to_s } ; end
+    def green_on_white    ; ANSI::Code.green_on_white    { to_s } ; end
+
+    def yellow_on_black   ; ANSI::Code.yellow_on_black   { to_s } ; end
+    def yellow_on_red     ; ANSI::Code.yellow_on_red     { to_s } ; end
+    def yellow_on_green   ; ANSI::Code.yellow_on_green   { to_s } ; end
+    def yellow_on_blue    ; ANSI::Code.yellow_on_blue    { to_s } ; end
+    def yellow_on_magenta ; ANSI::Code.yellow_on_magenta { to_s } ; end
+    def yellow_on_cyan    ; ANSI::Code.yellow_on_cyan    { to_s } ; end
+    def yellow_on_white   ; ANSI::Code.yellow_on_white   { to_s } ; end
+
+    def blue_on_black     ; ANSI::Code.blue_on_black     { to_s } ; end
+    def blue_on_red       ; ANSI::Code.blue_on_red       { to_s } ; end
+    def blue_on_green     ; ANSI::Code.blue_on_green     { to_s } ; end
+    def blue_on_yellow    ; ANSI::Code.blue_on_yellow    { to_s } ; end
+    def blue_on_magenta   ; ANSI::Code.blue_on_magenta   { to_s } ; end
+    def blue_on_cyan      ; ANSI::Code.blue_on_cyan      { to_s } ; end
+    def blue_on_white     ; ANSI::Code.blue_on_white     { to_s } ; end
+
+    def magenta_on_black  ; ANSI::Code.magenta_on_black  { to_s } ; end
+    def magenta_on_red    ; ANSI::Code.magenta_on_red    { to_s } ; end
+    def magenta_on_green  ; ANSI::Code.magenta_on_green  { to_s } ; end
+    def magenta_on_yellow ; ANSI::Code.magenta_on_yellow { to_s } ; end
+    def magenta_on_blue   ; ANSI::Code.magenta_on_blue   { to_s } ; end
+    def magenta_on_cyan   ; ANSI::Code.magenta_on_cyan   { to_s } ; end
+    def magenta_on_white  ; ANSI::Code.magenta_on_white  { to_s } ; end
+
+    def cyan_on_black     ; ANSI::Code.cyan_on_black     { to_s } ; end
+    def cyan_on_red       ; ANSI::Code.cyan_on_red       { to_s } ; end
+    def cyan_on_green     ; ANSI::Code.cyan_on_green     { to_s } ; end
+    def cyan_on_yellow    ; ANSI::Code.cyan_on_yellow    { to_s } ; end
+    def cyan_on_blue      ; ANSI::Code.cyan_on_blue      { to_s } ; end
+    def cyan_on_magenta   ; ANSI::Code.cyan_on_magenta   { to_s } ; end
+    def cyan_on_white     ; ANSI::Code.cyan_on_white     { to_s } ; end
+
+    def white_on_black    ; ANSI::Code.white_on_black    { to_s } ; end
+    def white_on_red      ; ANSI::Code.white_on_red      { to_s } ; end
+    def white_on_green    ; ANSI::Code.white_on_green    { to_s } ; end
+    def white_on_yellow   ; ANSI::Code.white_on_yellow   { to_s } ; end
+    def white_on_blue     ; ANSI::Code.white_on_blue     { to_s } ; end
+    def white_on_magenta  ; ANSI::Code.white_on_magenta  { to_s } ; end
+    def white_on_cyan     ; ANSI::Code.white_on_cyan     { to_s } ; end
+
+    # Move cursor to line and column, insert +self.to_s+ and return to
+    # original positon.
+    def display(line, column=0)
+      result = "\e[s"
+      result << "\e[#{line.to_i};#{column.to_i}H"
+      result << to_s
+      result << "\e[u"
+      result
+    end
+
+  end
+
+end