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/table.rb

@@ -0,0 +1,179 @@
+require 'ansi/core'
+require 'ansi/terminal'
+
+module ANSI
+
+  class Table
+
+    # The Table class can be used to output nicely formatted
+    # tables with division lines and alignment.
+    #
+    # table - array of array
+    #
+    # options[:align]   - align :left or :right
+    # options[:padding] - space to add to each cell
+    # options[:fit]     - fit to screen width
+    # options[:border]  - 
+    #
+    # The +format+ block must return ANSI codes to apply
+    # to each cell.
+    #
+    # Other Implementations:
+    #
+    # * http://github.com/visionmedia/terminal-table
+    # * http://github.com/aptinio/text-table
+    #
+    # TODO: Support for table headers and footers.
+    def initialize(table, options={}, &format)
+      @table   = table
+      @padding = options[:padding] || 0
+      @align   = options[:align]
+      @fit     = options[:fit]
+      @border  = options[:border]
+      #@ansi    = [options[:ansi]].flatten
+      @format  = format
+
+      @pad = " " * @padding
+    end
+
+    #
+    attr_accessor :table
+
+    # Fit to scree width.
+    attr_accessor :fit
+
+    #
+    attr_accessor :padding
+
+    #
+    attr_accessor :align
+
+    #
+    attr_accessor :format
+
+    #
+    attr_accessor :border
+
+    #
+    def to_s #(fit=false)
+      #row_count = table.size
+      #col_count = table[0].size
+
+      max = max_columns(fit)
+
+      div = dividing_line
+      top = div #.gsub('+', ".")
+      bot = div #.gsub('+', "'")
+
+      body = []
+      table.each_with_index do |row, r|
+         body_row = []
+         row.each_with_index do |cell, c|
+           t = cell_template(max[c])
+           s = t % cell.to_s
+           body_row << apply_format(s, cell, c, r)
+         end
+         body << "| " + body_row.join(' | ') + " |"
+      end
+
+      if border
+        body = body.join("\n#{div}\n")
+      else
+        body = body.join("\n")
+      end
+
+      "#{top}\n#{body}\n#{bot}\n"
+    end
+
+  private
+
+    # TODO: look at the lines and figure out how many columns will fit
+    def fit_width
+      width = Terminal.terminal_width
+      ((width.to_f / column_size) - (padding + 3)).to_i
+    end
+
+    # Calculate the maximun column sizes.
+    #
+    # @return [Array] maximum size for each column
+    def max_columns(fit=false)
+      max = Array.new(column_size, 0)
+      table.each do |row|
+        row.each_with_index do |col, index|
+          col = col.to_s
+          col = col.unansi
+          if fit
+            max[index] = [max[index], col.size, fit_width].max
+          else
+            max[index] = [max[index], col.size].max
+          end
+        end
+      end
+      max
+    end
+
+    # Number of columns based on the first row of table.
+    #
+    # @return [Integer] number of columns
+    def column_size
+      table.first.size
+    end
+
+    #
+    def cell_template(max)
+      case align
+      when :right, 'right'
+        "#{@pad}%#{max}s"
+      else
+        "%-#{max}s#{@pad}"
+      end
+    end
+
+    # TODO: make more efficient
+    def dividing_line
+      tmp = max_columns(fit).map{ |m| "%#{m}s" }.join(" | ")
+      tmp = "| #{tmp} |"
+      lin = (tmp % (['-'] * column_size)).gsub(/[^\|]/, '-').gsub('|', '+')
+      lin
+    end
+
+    #def dividing_line_top
+    #  dividing_line.gsub('+', '.')
+    #end
+
+    #def dividing_line_bottom
+    #  dividing_line.gsub('+', "'")
+    #end
+
+    #
+    def apply_format(str, cell, col, row)
+      if @format
+        str.ansi(*ansi_formating(cell, col, row))
+      else
+        str
+      end 
+    end
+
+    #
+    def ansi_formating(cell, col, row)
+      if @format
+        case @format.arity
+        when 0
+          f = @format[]
+        when 1
+          f = @format[cell]
+        when 2 
+          f = @format[row, col]
+        else
+          f = @format[cell, row, col]
+        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/terminal.rb

@@ -0,0 +1,44 @@
+module ANSI
+
+  # = Terminal
+  #
+  # This library is based of HighLine's SystemExtensions
+  # by James Edward Gray II.
+  #
+  # Copyright 2006 Gray Productions
+  #
+  # Distributed under the tems of the
+  # {Ruby software license}[http://www.ruby-lang.org/en/LICENSE.txt].
+
+  module Terminal
+
+    module_function
+
+    modes = %w{win32 termios curses stty}
+
+    # This section builds character reading and terminal size functions
+    # to suit the proper platform we're running on.
+    #
+    # Be warned: Here be dragons!
+    #
+    begin
+      require 'ansi/terminal/' + (mode = modes.shift)
+      CHARACTER_MODE = mode
+    rescue LoadError
+      retry
+    end
+
+    # Get the width of the terminal window.
+    def terminal_width
+      terminal_size.first
+    end
+
+    # Get the height of the terminal window.
+    def terminal_height
+      terminal_size.last
+    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/terminal/curses.rb

@@ -0,0 +1,26 @@
+module ANSI
+
+  module Terminal
+    require 'curses'
+
+    module_function
+
+    #CHARACTER_MODE = "curses"    # For Debugging purposes only.
+
+    #
+    # Curses savvy getc().
+    #
+    def get_character(input = STDIN)
+      Curses.getch()
+    end
+
+    def terminal_size
+      Curses.init_screen
+      w, r = Curses.cols, Curses.lines
+      Curses.close_screen
+      return w, r
+    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/terminal/stty.rb

@@ -0,0 +1,62 @@
+module ANSI
+
+  module Terminal
+    module_function
+
+    #COLS_FALLBACK = 80
+    #ROWS_FALLBACK = 25
+
+    #CHARACTER_MODE = "stty"    # For Debugging purposes only.
+
+    #
+    # Unix savvy getc().  (second choice)
+    #
+    # *WARNING*:  This method requires the external "stty" program!
+    #
+    def get_character(input = STDIN)
+      raw_no_echo_mode
+
+      begin
+        input.getc
+      ensure
+        restore_mode
+      end
+    end
+
+    #
+    # Switched the input mode to raw and disables echo.
+    #
+    # *WARNING*:  This method requires the external "stty" program!
+    #
+    def raw_no_echo_mode
+      @state = `stty -g`
+      system "stty raw -echo cbreak isig"
+    end
+
+    #
+    # Restores a previously saved input mode.
+    #
+    # *WARNING*:  This method requires the external "stty" program!
+    #
+    def restore_mode
+      system "stty #{@state}"
+    end
+
+    # A Unix savvy method to fetch the console columns, and rows.
+    def terminal_size
+      if /solaris/ =~ RUBY_PLATFORM && (`stty` =~ /\brows = (\d+).*\bcolumns = (\d+)/)
+        w, r = [$2, $1]
+      else
+        w, r = `stty size`.split.reverse
+      end
+      w = `tput cols` unless w  # last ditch effort to at least get width
+
+      w = w.to_i if w
+      r = r.to_i if r
+
+      return w, r
+    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/terminal/termios.rb

@@ -0,0 +1,68 @@
+module ANSI
+
+  module Terminal
+    require "termios"             # Unix, first choice.
+
+    module_function
+
+    #CHARACTER_MODE = "termios"    # For Debugging purposes only.
+
+    #
+    # Unix savvy getc().  (First choice.)
+    #
+    # *WARNING*:  This method requires the "termios" library!
+    #
+    def get_character( input = STDIN )
+      old_settings = Termios.getattr(input)
+
+      new_settings                     =  old_settings.dup
+      new_settings.c_lflag             &= ~(Termios::ECHO | Termios::ICANON)
+      new_settings.c_cc[Termios::VMIN] =  1
+
+      begin
+        Termios.setattr(input, Termios::TCSANOW, new_settings)
+        input.getc
+      ensure
+        Termios.setattr(input, Termios::TCSANOW, old_settings)
+      end
+    end
+
+    # A Unix savvy method to fetch the console columns, and rows.
+    def terminal_size
+      if /solaris/ =~ RUBY_PLATFORM && (`stty` =~ /\brows = (\d+).*\bcolumns = (\d+)/)
+        w, r = [$2, $1]
+      else
+        w, r = `stty size`.split.reverse
+      end
+      w = `tput cols` unless w  # last ditch effort to at least get width
+
+      w = w.to_i if w
+      r = r.to_i if r
+
+      return w, r
+    end
+
+    # Console screen width (taken from progress bar)
+    #
+    # NOTE: Don't know how portable #screen_width is.
+    # TODO: How to fit into system?
+    #
+    def screen_width(out=STDERR)
+      default_width = ENV['COLUMNS'] || 76
+      begin
+        tiocgwinsz = 0x5413
+        data = [0, 0, 0, 0].pack("SSSS")
+        if out.ioctl(tiocgwinsz, data) >= 0 then
+          rows, cols, xpixels, ypixels = data.unpack("SSSS")
+          if cols >= 0 then cols else default_width end
+        else
+          default_width
+        end
+      rescue Exception
+        default_width
+      end
+    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/terminal/win32.rb

@@ -0,0 +1,107 @@
+module ANSI
+
+  module Terminal
+    # Cygwin will look like Windows, but we want to treat it like a Posix OS:
+    raise LoadError, "Cygwin is a Posix OS." if RUBY_PLATFORM =~ /\bcygwin\b/i
+
+    require "Win32API"             # See if we're on Windows.
+
+    module_function
+
+    #CHARACTER_MODE = "Win32API"    # For Debugging purposes only.
+
+    #
+    # Windows savvy getc().
+    #
+    #
+    def get_character( input = STDIN )
+      @stdin_handle ||= GetStdHandle(STD_INPUT_HANDLE)
+
+      begin
+          SetConsoleEcho(@stdin_handle, false)
+          input.getc
+      ensure
+          SetConsoleEcho(@stdin_handle, true)
+      end
+    end
+
+    # A Windows savvy method to fetch the console columns, and rows.
+    def terminal_size
+      stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE)
+
+      bufx, bufy, curx, cury, wattr, left, top, right, bottom, maxx, maxy =
+        GetConsoleScreenBufferInfo(stdout_handle)
+      return right - left + 1, bottom - top + 1
+    end
+
+    # windows savvy console echo toggler
+    def SetConsoleEcho( console_handle, on )
+      mode = GetConsoleMode(console_handle)
+
+      # toggle the console echo bit
+      if on
+          mode |=  ENABLE_ECHO_INPUT
+      else
+          mode &= ~ENABLE_ECHO_INPUT
+      end
+
+      ok = SetConsoleMode(console_handle, mode)
+    end
+
+    # win32 console APIs
+
+    STD_INPUT_HANDLE  = -10
+    STD_OUTPUT_HANDLE = -11
+    STD_ERROR_HANDLE  = -12
+
+    ENABLE_PROCESSED_INPUT    = 0x0001
+    ENABLE_LINE_INPUT         = 0x0002
+    ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002
+    ENABLE_ECHO_INPUT         = 0x0004
+    ENABLE_WINDOW_INPUT       = 0x0008
+    ENABLE_MOUSE_INPUT        = 0x0010
+    ENABLE_INSERT_MODE        = 0x0020
+    ENABLE_QUICK_EDIT_MODE    = 0x0040
+
+    @@apiGetStdHandle               = nil
+    @@apiGetConsoleMode             = nil
+    @@apiSetConsoleMode             = nil
+    @@apiGetConsoleScreenBufferInfo = nil
+
+    def GetStdHandle( handle_type )
+      @@apiGetStdHandle ||= Win32API.new( "kernel32", "GetStdHandle",
+                                          ['L'], 'L' )
+
+      @@apiGetStdHandle.call( handle_type )
+    end
+
+    def GetConsoleMode( console_handle )
+      @@apiGetConsoleMode ||= Win32API.new( "kernel32", "GetConsoleMode",
+                                            ['L', 'P'], 'I' )
+
+      mode = ' ' * 4
+      @@apiGetConsoleMode.call(console_handle, mode)
+      mode.unpack('L')[0]
+    end
+
+    def SetConsoleMode( console_handle, mode )
+      @@apiSetConsoleMode ||= Win32API.new( "kernel32", "SetConsoleMode",
+                                            ['L', 'L'], 'I' )
+
+      @@apiSetConsoleMode.call(console_handle, mode) != 0
+    end
+
+    def GetConsoleScreenBufferInfo( console_handle )
+      @@apiGetConsoleScreenBufferInfo ||=
+        Win32API.new( "kernel32", "GetConsoleScreenBufferInfo",
+                      ['L', 'P'], 'L' )
+
+      format = 'SSSSSssssSS'
+      buf    = ([0] * format.size).pack(format)
+      @@apiGetConsoleScreenBufferInfo.call(console_handle, buf)
+      buf.unpack(format)
+    end
+
+  end
+
+end