paynow_sdk 1.0.9 → 1.1.2

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

@@ -1,349 +0,0 @@
-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.7.0/gems/ansi-1.5.0/lib/ansi/columns.rb

@@ -1,197 +0,0 @@
-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.7.0/gems/ansi-1.5.0/lib/ansi/constants.rb

@@ -1,25 +0,0 @@
-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.7.0/gems/ansi-1.5.0/lib/ansi/core.rb

@@ -1,30 +0,0 @@
-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
-