chikari_palindrome 0.1.0

data/vendor/cache/ruby/2.7.0/gems/chikari_palindrome-0.1.0/vendor/cache/ruby/2.7.0/gems/ansi-1.5.0/lib/ansi/columns.rb

@@ -0,0 +1,197 @@
+require 'ansi/terminal'
+
+module ANSI
+
+  #
+  class Columns
+
+    # Create a column-based layout.
+    #
+    # @param [String,Array] list
+    #   Multiline String or Array of strings to columnize.
+    #
+    # @param [Hash] options
+    #   Options to customize columnization.
+    #
+    # @option options [Fixnum] :columns
+    #   Number of columns.
+    #
+    # @option options [Symbol] :align
+    #   Column alignment, either :left, :right or :center.
+    #
+    # @option options [String,Fixnum] :padding
+    #   String or number or spaces to append to each column.
+    #
+    # The +format+ block MUST return ANSI codes.
+    def initialize(list, options={}, &format)
+      self.list = list
+
+      self.columns = options[:columns] || options[:cols]
+      self.padding = options[:padding] || 1
+      self.align   = options[:align]   || :left
+      #self.ansi    = options[:ansi]
+      self.format  = format
+
+      #@columns = nil if @columns == 0
+    end
+
+    #
+    def inspect
+      "#<#{self.class}:#{object_id} #{list.inspect} x #{columns}>"
+    end
+
+    # List layout into columns. Each new line is taken to be 
+    # a row-column cell.
+    attr :list
+
+    def list=(list)
+      case list
+      when ::String
+        @list = list.lines.to_a.map{ |e| e.chomp("\n") }
+      when ::Array
+        @list = list.map{ |e| e.to_s }
+      end
+    end
+
+    # Default number of columns to display. If nil then the number
+    # of coumns is estimated from the size of the terminal.
+    attr :columns
+
+    # Set column count ensuring value is either an integer or nil.
+    # The the value given is zero, it will be taken to mean the same
+    # as nil, which means fit-to-screen.
+    def columns=(integer)
+      integer = integer.to_i
+      @columns = (integer.zero? ? nil : integer)
+    end
+
+    # Padding size to apply to cells.
+    attr :padding
+
+    # Set padding to string or number (of spaces).
+    def padding=(pad)
+      case pad
+      when Numeric
+        @padding = ' ' * pad.to_i
+      else
+        @padding = pad.to_s
+      end
+    end
+
+    # Alignment to apply to cells.
+    attr :align
+
+    # Set alignment ensuring value is a symbol.
+    #
+    # @param [#to_sym] symbol
+    #   Either `:right`, `:left` or `:center`.
+    #
+    # @return [Symbol] The given symbol.
+    def align=(symbol)
+      symbol = symbol.to_sym
+      raise ArgumentError, "invalid alignment -- #{symbol.inspect}" \
+            unless [:left, :right, :center].include?(symbol)
+      @align = symbol
+    end
+
+    # Formating to apply to cells.
+    attr :format
+
+    # Set formatting procedure. The procedure must return
+    # ANSI codes, suitable for passing to String#ansi method.
+    def format=(procedure)
+      @format = procedure ? procedure.to_proc : nil
+    end
+
+    # TODO: Should #to_s also take options and formatting block?
+    #       Maybe instead have hoin take all these and leave #to_s bare.
+
+    # Return string in column layout. The number of columns is determined
+    # by the `columns` property or overriden by +cols+ argument.
+    def to_s(cols=nil)
+      to_s_columns(cols || columns)
+    end
+
+    #
+    def join(cols=nil)
+      to_s_columns(cols || columns)
+    end
+
+  private
+
+    # Layout string lines into columns.
+    #
+    # @todo Put in empty strings for blank cells.
+    # @todo Centering look like it's off by one to the right.
+    #
+    def to_s_columns(columns=nil)
+      lines = list.to_a
+      count = lines.size
+      max   = lines.map{ |l| l.size }.max
+
+      if columns.nil?
+        width = Terminal.terminal_width
+        columns = (width / (max + padding.size)).to_i
+      end
+
+      rows = []
+      mod = (count / columns.to_f).to_i
+      mod += 1 if count % columns != 0
+
+      lines.each_with_index do |line, index|
+        (rows[index % mod] ||=[]) << line.strip
+      end
+
+      pad = padding
+      tmp = template(max, pad)
+      str = ""
+      rows.each_with_index do |row, ri|
+        row.each_with_index do |cell, ci|
+          ansi_codes = ansi_formatting(cell, ci, ri)
+          if ansi_codes.empty?
+            str << (tmp % cell)
+          else
+            str << (tmp % cell).ansi(*ansi_codes)
+          end
+        end
+        str.rstrip!
+        str << "\n"
+      end
+      str
+    end
+
+    # Aligns the cell left or right.
+    def template(max, pad)
+      case align
+      when :center, 'center'
+        offset = " " * (max / 2)
+        "#{offset}%#{max}s#{offset}#{pad}"
+      when :right, 'right'
+        "%#{max}s#{pad}"
+      else
+        "%-#{max}s#{pad}"
+      end
+    end
+
+    # Used to apply ANSI formatting to each cell.
+    def ansi_formatting(cell, col, row)
+      if @format
+        case @format.arity
+        when 0
+          f = @format[]
+        when 1
+          f = @format[cell]
+        when 2 
+          f = @format[col, row]
+        else
+          f = @format[cell, col, row]
+        end
+      else
+        f = nil
+      end
+      [f].flatten.compact
+    end
+
+  end
+
+end

data/vendor/cache/ruby/2.7.0/gems/chikari_palindrome-0.1.0/vendor/cache/ruby/2.7.0/gems/ansi-1.5.0/lib/ansi/constants.rb

@@ -0,0 +1,25 @@
+module ANSI
+
+  require 'ansi/chart'
+
+  # Converts {CHART} and {SPECIAL_CHART} entries into constants.
+  # So for example, the CHART entry for :red becomes:
+  #
+  #   ANSI::Constants::RED  #=> "\e[31m"
+  #
+  # The ANSI Constants are include into ANSI::Code and can be included
+  # any where will they would be of use.
+  #
+  module Constants
+
+    CHART.each do |name, code|
+      const_set(name.to_s.upcase, "\e[#{code}m")
+    end
+
+    SPECIAL_CHART.each do |name, code|
+      const_set(name.to_s.upcase, code)
+    end
+
+  end
+
+end

data/vendor/cache/ruby/2.7.0/gems/chikari_palindrome-0.1.0/vendor/cache/ruby/2.7.0/gems/ansi-1.5.0/lib/ansi/core.rb

@@ -0,0 +1,30 @@
+require 'ansi/code'
+require 'ansi/chain'
+
+class ::String
+
+  #
+  def ansi(*codes)
+    if codes.empty?
+      ANSI::Chain.new(self)
+    else
+      ANSI::Code.ansi(self, *codes)
+    end
+  end
+
+  #
+  def ansi!(*codes)
+    replace(ansi(*codes))
+  end
+
+  #
+  def unansi
+    ANSI::Code.unansi(self)
+  end
+
+  #
+  def unansi!
+    replace(unansi)
+  end
+end
+

data/vendor/cache/ruby/2.7.0/gems/chikari_palindrome-0.1.0/vendor/cache/ruby/2.7.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