hirohig_palindrome 0.1.0

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

@@ -0,0 +1,349 @@
+module ANSI
+
+  # Global variable can be used to prevent ANSI codes
+  # from being used in ANSI's methods that do so to string.
+  #
+  # NOTE: This has no effect on methods that return ANSI codes.
+  $ansi = true
+
+  if RUBY_PLATFORM =~ /(win32|w32)/
+    begin
+      require 'Win32/Console/ANSI'
+    rescue LoadError
+      warn "ansi: 'gem install win32console' to use color on Windows"
+      $ansi = false
+    end
+  end
+
+  require 'ansi/constants'
+
+  # TODO: up, down, right, left, etc could have yielding methods too?
+
+  # ANSI Codes
+  #
+  # Ansi::Code module makes it very easy to use ANSI codes.
+  # These are especially nice for beautifying shell output.
+  #
+  #   Ansi::Code.red + "Hello" + Ansi::Code.blue + "World"
+  #   => "\e[31mHello\e[34mWorld"
+  #
+  #   Ansi::Code.red{ "Hello" } + Ansi::Code.blue{ "World" }
+  #   => "\e[31mHello\e[0m\e[34mWorld\e[0m"
+  #
+  # IMPORTANT! Do not mixin Ansi::Code, instead use {ANSI::Mixin}.
+  #
+  # See {ANSI::CHART} for list of all supported codes.
+  #
+  module Code
+    extend self
+
+    # include ANSI Constants
+    include Constants
+
+    # Regexp for matching most ANSI codes.
+    PATTERN = /\e\[(\d+)m/
+
+    # ANSI clear code.
+    ENDCODE = "\e[0m"
+
+    # List of primary styles.
+    def self.styles
+      %w{bold dark italic underline underscore blink rapid reverse negative concealed strike}
+    end
+
+    # List of primary colors.
+    def self.colors
+      %w{black red green yellow blue magenta cyan white}
+    end
+
+    # Return ANSI code given a list of symbolic names.
+    def [](*codes)
+      code(*codes)
+    end
+
+    # Dynamically create color on color methods.
+    #
+    # @deprecated
+    #
+    colors.each do |color|
+      colors.each do |on_color|
+        module_eval <<-END, __FILE__, __LINE__
+          def #{color}_on_#{on_color}(string=nil)
+            if string
+              return string unless $ansi
+              #warn "use ANSI block notation for future versions"
+              return #{color.upcase} + ON_#{color.upcase} + string + ENDCODE
+            end
+            if block_given?
+              return yield unless $ansi
+              #{color.upcase} + ON_#{on_color.upcase} + yield.to_s + ENDCODE
+            else
+              #{color.upcase} + ON_#{on_color.upcase}
+            end
+          end
+        END
+      end
+    end
+
+    # Use method missing to dispatch ANSI code methods.
+    def method_missing(code, *args, &blk)
+      esc = nil
+
+      if CHART.key?(code)
+        esc = "\e[#{CHART[code]}m"
+      elsif SPECIAL_CHART.key?(code)
+        esc = SPECIAL_CHART[code]
+      end
+
+      if esc
+        if string = args.first
+          return string unless $ansi
+          #warn "use ANSI block notation for future versions"
+          return "#{esc}#{string}#{ENDCODE}"
+        end
+        if block_given?
+          return yield unless $ansi
+          return "#{esc}#{yield}#{ENDCODE}"
+        end
+        esc
+      else
+        super(code, *args, &blk)
+      end
+    end
+
+    # TODO: How to deal with position codes when $ansi is false?
+    # Should we raise an error or just not push the codes?
+    # For now, we will leave this it as is.
+
+    # Like +move+ but returns to original position after
+    # yielding the block.
+    def display(line, column=0) #:yield:
+      result = "\e[s"
+      result << "\e[#{line.to_i};#{column.to_i}H"
+      if block_given?
+        result << yield
+        result << "\e[u"
+      #elsif string
+      #  result << string
+      #  result << "\e[u"
+      end
+      result
+    end
+
+    # Move cursor to line and column.
+    def move(line, column=0)
+      "\e[#{line.to_i};#{column.to_i}H"
+    end
+
+    # Move cursor up a specified number of spaces.
+    def up(spaces=1)
+      "\e[#{spaces.to_i}A"
+    end
+
+    # Move cursor down a specified number of spaces.
+    def down(spaces=1)
+      "\e[#{spaces.to_i}B"
+    end
+
+    # Move cursor left a specified number of spaces.
+    def left(spaces=1)
+      "\e[#{spaces.to_i}D"
+    end
+    alias :back :left
+
+    # Move cursor right a specified number of spaces.
+    def right(spaces=1)
+      "\e[#{spaces.to_i}C"
+    end
+    alias :forward :right
+
+    ##
+    #def position
+    #  "\e[#;#R"
+    #end
+
+    # Apply ANSI codes to a first argument or block value.
+    #
+    # @example
+    #   ansi("Valentine", :red, :on_white)
+    #
+    # @example
+    #   ansi(:red, :on_white){ "Valentine" }
+    #
+    # @return [String]
+    #   String wrapped ANSI code.
+    #
+    def ansi(*codes) #:yield:
+      if block_given?
+        string = yield.to_s
+      else
+        # first argument must be the string
+        string = codes.shift.to_s
+      end
+
+      return string unless $ansi
+
+      c = code(*codes)
+
+      c + string.gsub(ENDCODE, ENDCODE + c) + ENDCODE
+    end
+
+    # TODO: Allow selective removal using *codes argument?
+
+    # Remove ANSI codes from string or block value.
+    #
+    # @param [String] string
+    #   String from which to remove ANSI codes.
+    #
+    # @return [String]
+    #   String wrapped ANSI code.
+    #
+    def unansi(string=nil) #:yield:
+      if block_given?
+        string = yield.to_s
+      else
+        string = string.to_s
+      end
+      string.gsub(PATTERN, '')
+    end
+
+    # Alias for #ansi method.
+    #
+    # @deprecated
+    #   Here for backward compatibility.
+    alias_method :style, :ansi
+
+    # Alias for #unansi method.
+    #
+    # @deprecated 
+    #   Here for backwards compatibility.
+    alias_method :unstyle, :unansi
+
+    # Alternate term for #ansi.
+    #
+    # @deprecated 
+    #   May change in future definition.
+    alias_method :color, :ansi
+
+    # Alias for unansi.
+    #
+    # @deprecated 
+    #   May change in future definition.
+    alias_method :uncolor, :unansi
+
+    # Look-up code from chart, or if Integer simply pass through.
+    # Also resolves :random and :on_random.
+    #
+    # @param codes [Array<Symbol,Integer]
+    #   Symbols or integers to convert to ANSI code.
+    #
+    # @return [String] ANSI code
+    def code(*codes)
+      list = []
+      codes.each do |code|
+        list << \
+          case code
+          when Integer
+            code
+          when Array
+            rgb_code(*code)
+          when :random, 'random'
+            random
+          when :on_random, 'on_random'
+            random(true)
+          when String
+            # TODO: code =~ /\d\d\d\d\d\d/ ?
+            if code.start_with?('#')
+              hex_code(code)
+            else
+              CHART[code.to_sym]
+            end
+          else
+            CHART[code.to_sym]
+          end
+      end
+      "\e[" + (list * ";") + "m"
+    end
+
+    # Provides a random primary ANSI color.
+    #
+    # @param background [Boolean]
+    #   Use `true` for background color, otherwise foreground color.
+    #
+    # @return [Integer] ANSI color number
+    def random(background=false)
+      (background ? 40 : 30) + rand(8)
+    end
+
+    # Creates an XTerm 256 color escape code from RGB value(s). The
+    # RGB value can be three arguments red, green and blue respectively
+    # each from 0 to 255, or the RGB value can be a single CSS-style
+    # hex string.
+    #
+    # @param background [Boolean]
+    #   Use `true` for background color, otherwise foreground color.
+    #
+    def rgb(*args)
+      case args.size
+      when 1, 2
+        hex, background = *args
+        esc = "\e[" + hex_code(hex, background) + "m"
+      when 3, 4
+        red, green, blue, background = *args
+        esc = "\e[" + rgb_code(red, green, blue, background) + "m"
+      else
+        raise ArgumentError
+      end
+
+      if block_given?
+        return yield.to_s unless $ansi
+        return "#{esc}#{yield}#{ENDCODE}"
+      else
+        return esc
+      end
+    end
+
+  #private
+
+    # Creates an xterm-256 color from rgb value.
+    #
+    # @param background [Boolean]
+    #   Use `true` for background color, otherwise foreground color.
+    #
+    def rgb_code(red, green, blue, background=false)
+      "#{background ? 48 : 38};5;#{rgb_256(red, green, blue)}"
+    end
+
+    # Creates an xterm-256 color code from a CSS-style color string.
+    #
+    # @param string [String]
+    #   Hex string in CSS style, .e.g. `#5FA0C2`.
+    #
+    # @param background [Boolean]
+    #   Use `true` for background color, otherwise foreground color.
+    #
+    def hex_code(string, background=false)
+      string.tr!('#','')
+      x = (string.size == 6 ? 2 : 1)
+      r, g, b = [0,1,2].map{ |i| string[i*x,2].to_i(16) }
+      rgb_code(r, g, b, background)
+    end
+
+    # Given red, green and blue values between 0 and 255, this method
+    # returns the closest XTerm 256 color value.
+    #
+    def rgb_256(r, g, b)
+      # TODO: what was rgb_valid for?
+      #r, g, b = [r, g, b].map{ |c| rgb_valid(c); (6 * (c.to_f / 256.0)).to_i }
+      r, g, b = [r, g, b].map{ |c| (6 * (c.to_f / 256.0)).to_i }
+      v = (r * 36 + g * 6 + b + 16).abs
+      raise ArgumentError, "RGB value is outside 0-255 range -- #{v}" if v > 255
+      v
+    end
+
+  end
+
+  #
+  extend Code
+end
+

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