RubyGems - paynow_sdk - Versions diffs - 0.2.0 → 1.0.0 - Mend

paynow_sdk 0.2.0 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2409) hide show

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.9/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.8/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.8/vendor/cache/ruby/2.7.0/gems/ansi-1.5.0/lib/ansi/columns.rb DELETED

@@ -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

@@ -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

@@ -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

@@ -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