paynow_sdk 0.1.1 → 0.1.8

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.0/vendor/cache/ruby/2.7.0/gems/ansi-1.5.0/lib/ansi/hexdump.rb

@@ -1,122 +0,0 @@
-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/cache/ruby/2.7.0/gems/paynow_sdk-0.1.0/vendor/cache/ruby/2.7.0/gems/ansi-1.5.0/lib/ansi/logger.rb

@@ -1,211 +0,0 @@
-# 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/cache/ruby/2.7.0/gems/paynow_sdk-0.1.0/vendor/cache/ruby/2.7.0/gems/ansi-1.5.0/lib/ansi/mixin.rb

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