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/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/cache/ruby/2.7.0/gems/paynow_sdk-0.1.0/vendor/cache/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/cache/ruby/2.7.0/gems/paynow_sdk-0.1.0/vendor/cache/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
-

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

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