paynow_sdk 1.0.9 → 1.1.2

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-1.0.0/vendor/cache/ruby/2.7.0/gems/netrc-0.11.0/lib/netrc.rb

@@ -1,251 +0,0 @@
-require 'rbconfig'
-
-class Netrc
-  VERSION = "0.11.0"
-
-  # see http://stackoverflow.com/questions/4871309/what-is-the-correct-way-to-detect-if-ruby-is-running-on-windows
-  WINDOWS = RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/
-  CYGWIN  = RbConfig::CONFIG["host_os"] =~ /cygwin/
-
-  def self.default_path
-    File.join(ENV['NETRC'] || home_path, netrc_filename)
-  end
-
-  def self.home_path
-    home = Dir.respond_to?(:home) ? Dir.home : ENV['HOME']
-
-    if WINDOWS && !CYGWIN
-      home ||= File.join(ENV['HOMEDRIVE'], ENV['HOMEPATH']) if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
-      home ||= ENV['USERPROFILE']
-      # XXX: old stuff; most likely unnecessary
-      home = home.tr("\\", "/") unless home.nil?
-    end
-
-    (home && File.readable?(home)) ? home : Dir.pwd
-  rescue ArgumentError
-    return Dir.pwd
-  end
-
-  def self.netrc_filename
-    WINDOWS && !CYGWIN ? "_netrc" : ".netrc"
-  end
-
-  def self.config
-    @config ||= {}
-  end
-
-  def self.configure
-    yield(self.config) if block_given?
-    self.config
-  end
-
-  def self.check_permissions(path)
-    perm = File.stat(path).mode & 0777
-    if perm != 0600 && !(WINDOWS) && !(Netrc.config[:allow_permissive_netrc_file])
-      raise Error, "Permission bits for '#{path}' should be 0600, but are "+perm.to_s(8)
-    end
-  end
-
-  # Reads path and parses it as a .netrc file. If path doesn't
-  # exist, returns an empty object. Decrypt paths ending in .gpg.
-  def self.read(path=default_path)
-    check_permissions(path)
-    data = if path =~ /\.gpg$/
-      decrypted = `gpg --batch --quiet --decrypt #{path}`
-      if $?.success?
-        decrypted
-      else
-        raise Error.new("Decrypting #{path} failed.") unless $?.success?
-      end
-    else
-      File.read(path)
-    end
-    new(path, parse(lex(data.lines.to_a)))
-  rescue Errno::ENOENT
-    new(path, parse(lex([])))
-  end
-
-  class TokenArray < Array
-    def take
-      if length < 1
-        raise Error, "unexpected EOF"
-      end
-      shift
-    end
-
-    def readto
-      l = []
-      while length > 0 && ! yield(self[0])
-        l << shift
-      end
-      return l.join
-    end
-  end
-
-  def self.lex(lines)
-    tokens = TokenArray.new
-    for line in lines
-      content, comment = line.split(/(\s*#.*)/m)
-      content.each_char do |char|
-        case char
-        when /\s/
-          if tokens.last && tokens.last[-1..-1] =~ /\s/
-            tokens.last << char
-          else
-            tokens << char
-          end
-        else
-          if tokens.last && tokens.last[-1..-1] =~ /\S/
-            tokens.last << char
-          else
-            tokens << char
-          end
-        end
-      end
-      if comment
-        tokens << comment
-      end
-    end
-    tokens
-  end
-
-  def self.skip?(s)
-    s =~ /^\s/
-  end
-
-
-
-  # Returns two values, a header and a list of items.
-  # Each item is a tuple, containing some or all of:
-  # - machine keyword (including trailing whitespace+comments)
-  # - machine name
-  # - login keyword (including surrounding whitespace+comments)
-  # - login
-  # - password keyword (including surrounding whitespace+comments)
-  # - password
-  # - trailing chars
-  # This lets us change individual fields, then write out the file
-  # with all its original formatting.
-  def self.parse(ts)
-    cur, item = [], []
-
-    unless ts.is_a?(TokenArray)
-      ts = TokenArray.new(ts)
-    end
-
-    pre = ts.readto{|t| t == "machine" || t == "default"}
-
-    while ts.length > 0
-      if ts[0] == 'default'
-        cur << ts.take.to_sym
-        cur << ''
-      else
-        cur << ts.take + ts.readto{|t| ! skip?(t)}
-        cur << ts.take
-      end
-
-      if ts.include?('login')
-        cur << ts.readto{|t| t == "login"} + ts.take + ts.readto{|t| ! skip?(t)}
-        cur << ts.take
-      end
-
-      if ts.include?('password')
-        cur << ts.readto{|t| t == "password"} + ts.take + ts.readto{|t| ! skip?(t)}
-        cur << ts.take
-      end
-
-      cur << ts.readto{|t| t == "machine" || t == "default"}
-
-      item << cur
-      cur = []
-    end
-
-    [pre, item]
-  end
-
-  def initialize(path, data)
-    @new_item_prefix = ''
-    @path = path
-    @pre, @data = data
-
-    if @data && @data.last && :default == @data.last[0]
-      @default = @data.pop
-    else
-      @default = nil
-    end
-  end
-
-  attr_accessor :new_item_prefix
-
-  def [](k)
-    if item = @data.detect {|datum| datum[1] == k}
-      Entry.new(item[3], item[5])
-    elsif @default
-      Entry.new(@default[3], @default[5])
-    end
-  end
-
-  def []=(k, info)
-    if item = @data.detect {|datum| datum[1] == k}
-      item[3], item[5] = info
-    else
-      @data << new_item(k, info[0], info[1])
-    end
-  end
-
-  def length
-    @data.length
-  end
-
-  def delete(key)
-    datum = nil
-    for value in @data
-      if value[1] == key
-        datum = value
-        break
-      end
-    end
-    @data.delete(datum)
-  end
-
-  def each(&block)
-    @data.each(&block)
-  end
-
-  def new_item(m, l, p)
-    [new_item_prefix+"machine ", m, "\n  login ", l, "\n  password ", p, "\n"]
-  end
-
-  def save
-    if @path =~ /\.gpg$/
-      e = IO.popen("gpg -a --batch --default-recipient-self -e", "r+") do |gpg|
-        gpg.puts(unparse)
-        gpg.close_write
-        gpg.read
-      end
-      raise Error.new("Encrypting #{@path} failed.") unless $?.success?
-      File.open(@path, 'w', 0600) {|file| file.print(e)}
-    else
-      File.open(@path, 'w', 0600) {|file| file.print(unparse)}
-    end
-  end
-
-  def unparse
-    @pre + @data.map do |datum|
-      datum = datum.join
-      unless datum[-1..-1] == "\n"
-        datum << "\n"
-      else
-        datum
-      end
-    end.join
-  end
-
-  Entry = Struct.new(:login, :password) do
-    alias to_ary to_a
-  end
-
-end
-
-class Netrc::Error < ::StandardError
-end

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-1.0.0/vendor/cache/ruby/2.7.0/gems/netrc-0.11.0/test/test_lex.rb

@@ -1,58 +0,0 @@
-$VERBOSE = true
-require 'minitest/autorun'
-
-require File.expand_path("#{File.dirname(__FILE__)}/../lib/netrc")
-
-class TestLex < Minitest::Test
-  def test_lex_empty
-    t = Netrc.lex([])
-    assert_equal([], t)
-  end
-
-  def test_lex_comment
-    t = Netrc.lex(["# foo\n"])
-    assert_equal(["# foo\n"], t)
-  end
-
-  def test_lex_comment_after_space
-    t = Netrc.lex([" # foo\n"])
-    assert_equal([" # foo\n"], t)
-  end
-
-  def test_lex_comment_after_word
-    t = Netrc.lex(["x # foo\n"])
-    assert_equal(["x", " # foo\n"], t)
-  end
-
-  def test_lex_comment_with_hash
-    t = Netrc.lex(["x # foo # bar\n"])
-    assert_equal(["x", " # foo # bar\n"], t)
-  end
-
-  def test_lex_word
-    t = Netrc.lex(["x"])
-    assert_equal(["x"], t)
-  end
-
-  def test_lex_two_lines
-    t = Netrc.lex(["x\ny\n"])
-    assert_equal(["x", "\n", "y", "\n"], t)
-  end
-
-  def test_lex_word_and_comment
-    t = Netrc.lex(["x\n", "# foo\n"])
-    assert_equal(["x", "\n", "# foo\n"], t)
-  end
-
-  def test_lex_six_words
-    t = Netrc.lex(["machine m login l password p\n"])
-    e = ["machine", " ", "m", " ", "login", " ", "l", " ", "password", " ", "p", "\n"]
-    assert_equal(e, t)
-  end
-
-  def test_lex_complex
-    t = Netrc.lex(["machine sub.domain.com  login email@domain.com  password pass\n"])
-    e = ["machine", " ", "sub.domain.com", "  ", "login", " ", "email@domain.com", "  ", "password", " ", "pass", "\n"]
-    assert_equal(e, t)
-  end
-end

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-1.0.0/vendor/cache/ruby/2.7.0/gems/netrc-0.11.0/test/test_netrc.rb

@@ -1,273 +0,0 @@
-$VERBOSE = true
-require 'minitest/autorun'
-require 'fileutils'
-
-require File.expand_path("#{File.dirname(__FILE__)}/../lib/netrc")
-require "rbconfig"
-
-class TestNetrc < Minitest::Test
-
-  def setup
-    Dir.glob('data/*.netrc').each{|f| File.chmod(0600, f)}
-    File.chmod(0644, "data/permissive.netrc")
-  end
-
-  def teardown
-    Dir.glob('data/*.netrc').each{|f| File.chmod(0644, f)}
-  end
-
-  def test_parse_empty
-    pre, items = Netrc.parse(Netrc.lex([]))
-    assert_equal("", pre)
-    assert_equal([], items)
-  end
-
-  def test_parse_file
-    pre, items = Netrc.parse(Netrc.lex(IO.readlines("data/sample.netrc")))
-    assert_equal("# this is my netrc\n", pre)
-    exp = [["machine ",
-            "m",
-            "\n  login ",
-            "l",
-            " # this is my username\n  password ",
-            "p",
-            "\n"]]
-    assert_equal(exp, items)
-  end
-
-  def test_login_file
-    pre, items = Netrc.parse(Netrc.lex(IO.readlines("data/login.netrc")))
-    assert_equal("# this is my login netrc\n", pre)
-    exp = [["machine ",
-            "m",
-            "\n  login ",
-            "l",
-            " # this is my username\n"]]
-    assert_equal(exp, items)
-  end
-
-  def test_password_file
-    pre, items = Netrc.parse(Netrc.lex(IO.readlines("data/password.netrc")))
-    assert_equal("# this is my password netrc\n", pre)
-    exp = [["machine ",
-            "m",
-            "\n  password ",
-            "p",
-            " # this is my password\n"]]
-    assert_equal(exp, items)
-  end
-
-  def test_missing_file
-    n = Netrc.read("data/nonexistent.netrc")
-    assert_equal(0, n.length)
-  end
-
-  def test_permission_error
-    original_windows = Netrc::WINDOWS
-    Netrc.send(:remove_const, :WINDOWS)
-    Netrc.const_set(:WINDOWS, false)
-    Netrc.read("data/permissive.netrc")
-    assert false, "Should raise an error if permissions are wrong on a non-windows system."
-  rescue Netrc::Error
-    assert true, ""
-  ensure
-    Netrc.send(:remove_const, :WINDOWS)
-    Netrc.const_set(:WINDOWS, original_windows)
-  end
-
-  def test_allow_permissive_netrc_file_option
-    Netrc.configure do |config|
-      config[:allow_permissive_netrc_file] = true
-    end
-    original_windows = Netrc::WINDOWS
-    Netrc.send(:remove_const, :WINDOWS)
-    Netrc.const_set(:WINDOWS, false)
-    Netrc.read("data/permissive.netrc")
-    assert true, ""
-  rescue Netrc::Error
-    assert false, "Should not raise an error if allow_permissive_netrc_file option is set to true"
-  ensure
-    Netrc.send(:remove_const, :WINDOWS)
-    Netrc.const_set(:WINDOWS, original_windows)
-    Netrc.configure do |config|
-      config[:allow_permissive_netrc_file] = false
-    end
-  end
-
-  def test_permission_error_windows
-    original_windows = Netrc::WINDOWS
-    Netrc.send(:remove_const, :WINDOWS)
-    Netrc.const_set(:WINDOWS, true)
-    Netrc.read("data/permissive.netrc")
-  rescue Netrc::Error
-    assert false, "Should not raise an error if permissions are wrong on a non-windows system."
-  ensure
-    Netrc.send(:remove_const, :WINDOWS)
-    Netrc.const_set(:WINDOWS, original_windows)
-  end
-
-  def test_round_trip
-    n = Netrc.read("data/sample.netrc")
-    assert_equal(IO.read("data/sample.netrc"), n.unparse)
-  end
-
-  def test_set
-    n = Netrc.read("data/sample.netrc")
-    n["m"] = "a", "b"
-    exp = "# this is my netrc\n"+
-          "machine m\n"+
-          "  login a # this is my username\n"+
-          "  password b\n"
-    assert_equal(exp, n.unparse)
-  end
-
-  def test_set_get
-    n = Netrc.read("data/sample.netrc")
-    n["m"] = "a", "b"
-    assert_equal(["a", "b"], n["m"].to_a)
-  end
-
-  def test_add
-    n = Netrc.read("data/sample.netrc")
-    n.new_item_prefix = "# added\n"
-    n["x"] = "a", "b"
-    exp = "# this is my netrc\n"+
-          "machine m\n"+
-          "  login l # this is my username\n"+
-          "  password p\n"+
-          "# added\n"+
-          "machine x\n"+
-          "  login a\n"+
-          "  password b\n"
-    assert_equal(exp, n.unparse)
-  end
-
-  def test_add_newlineless
-    n = Netrc.read("data/newlineless.netrc")
-    n.new_item_prefix = "# added\n"
-    n["x"] = "a", "b"
-    exp = "# this is my netrc\n"+
-          "machine m\n"+
-          "  login l # this is my username\n"+
-          "  password p\n"+
-          "# added\n"+
-          "machine x\n"+
-          "  login a\n"+
-          "  password b\n"
-    assert_equal(exp, n.unparse)
-  end
-
-  def test_add_get
-    n = Netrc.read("data/sample.netrc")
-    n.new_item_prefix = "# added\n"
-    n["x"] = "a", "b"
-    assert_equal(["a", "b"], n["x"].to_a)
-  end
-
-  def test_get_missing
-    n = Netrc.read("data/sample.netrc")
-    assert_equal(nil, n["x"])
-  end
-
-  def test_save
-    n = Netrc.read("data/sample.netrc")
-    n.save
-    assert_equal(File.read("data/sample.netrc"), n.unparse)
-  end
-
-  def test_save_create
-    FileUtils.rm_f("/tmp/created.netrc")
-    n = Netrc.read("/tmp/created.netrc")
-    n.save
-    unless Netrc::WINDOWS
-      assert_equal(0600, File.stat("/tmp/created.netrc").mode & 0777)
-    end
-  end
-
-  def test_encrypted_roundtrip
-    if `gpg --list-keys 2> /dev/null` != ""
-      FileUtils.rm_f("/tmp/test.netrc.gpg")
-      n = Netrc.read("/tmp/test.netrc.gpg")
-      n["m"] = "a", "b"
-      n.save
-      assert_equal(0600, File.stat("/tmp/test.netrc.gpg").mode & 0777)
-      netrc = Netrc.read("/tmp/test.netrc.gpg")["m"]
-      assert_equal("a", netrc.login)
-      assert_equal("b", netrc.password)
-    end
-  end
-
-  def test_missing_environment
-    nil_home = nil
-    ENV["HOME"], nil_home = nil_home, ENV["HOME"]
-    assert_equal File.join(Dir.pwd, '.netrc'), Netrc.default_path
-  ensure
-    ENV["HOME"], nil_home = nil_home, ENV["HOME"]
-  end
-
-  def test_netrc_environment_variable
-    ENV["NETRC"] = File.join(Dir.pwd, 'data')
-    assert_equal File.join(Dir.pwd, 'data', '.netrc'), Netrc.default_path
-  ensure
-    ENV.delete("NETRC")
-  end
-
-  def test_read_entry
-    entry = Netrc.read("data/sample.netrc")['m']
-    assert_equal 'l', entry.login
-    assert_equal 'p', entry.password
-
-    # hash-style
-    assert_equal 'l', entry[:login]
-    assert_equal 'p', entry[:password]
-  end
-
-  def test_write_entry
-    n = Netrc.read("data/sample.netrc")
-    entry = n['m']
-    entry.login    = 'new_login'
-    entry.password = 'new_password'
-    n['m'] = entry
-    assert_equal(['new_login', 'new_password'], n['m'].to_a)
-  end
-
-  def test_entry_splat
-    e = Netrc::Entry.new("user", "pass")
-    user, pass = *e
-    assert_equal("user", user)
-    assert_equal("pass", pass)
-  end
-
-  def test_entry_implicit_splat
-    e = Netrc::Entry.new("user", "pass")
-    user, pass = e
-    assert_equal("user", user)
-    assert_equal("pass", pass)
-  end
-
-  def test_with_default
-    netrc = Netrc.read('data/sample_with_default.netrc')
-    assert_equal(['l', 'p'], netrc['m'].to_a)
-    assert_equal(['default_login', 'default_password'], netrc['unknown'].to_a)
-  end
-
-  def test_multi_without_default
-    netrc = Netrc.read('data/sample_multi.netrc')
-    assert_equal(['lm', 'pm'], netrc['m'].to_a)
-    assert_equal(['ln', 'pn'], netrc['n'].to_a)
-    assert_equal([], netrc['other'].to_a)
-  end
-
-  def test_multi_with_default
-    netrc = Netrc.read('data/sample_multi_with_default.netrc')
-    assert_equal(['lm', 'pm'], netrc['m'].to_a)
-    assert_equal(['ln', 'pn'], netrc['n'].to_a)
-    assert_equal(['ld', 'pd'], netrc['other'].to_a)
-  end
-
-  def test_default_only
-    netrc = Netrc.read('data/default_only.netrc')
-    assert_equal(['ld', 'pd'], netrc['m'].to_a)
-    assert_equal(['ld', 'pd'], netrc['other'].to_a)
-  end
-end

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-1.0.0/vendor/cache/ruby/2.7.0/gems/netrc-0.11.0/test/test_parse.rb

@@ -1,34 +0,0 @@
-$VERBOSE = true
-require 'minitest/autorun'
-
-require File.expand_path("#{File.dirname(__FILE__)}/../lib/netrc")
-
-class TestParse < Minitest::Test
-  def test_parse_empty
-    pre, items = Netrc.parse([])
-    assert_equal("", pre)
-    assert_equal([], items)
-  end
-
-  def test_parse_comment
-    pre, items = Netrc.parse(["# foo\n"])
-    assert_equal("# foo\n", pre)
-    assert_equal([], items)
-  end
-
-  def test_parse_item
-    t = ["machine", " ", "m", " ", "login", " ", "l", " ", "password", " ", "p", "\n"]
-    pre, items = Netrc.parse(t)
-    assert_equal("", pre)
-    e = [["machine ", "m", " login ", "l", " password ", "p", "\n"]]
-    assert_equal(e, items)
-  end
-
-  def test_parse_two_items
-    t = ["machine", " ", "m", " ", "login", " ", "l", " ", "password", " ", "p", "\n"] * 2
-    pre, items = Netrc.parse(t)
-    assert_equal("", pre)
-    e = [["machine ", "m", " login ", "l", " password ", "p", "\n"]] * 2
-    assert_equal(e, items)
-  end
-end

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-1.0.0/vendor/cache/ruby/2.7.0/gems/rake-12.3.3/CONTRIBUTING.rdoc

@@ -1,43 +0,0 @@
-= Source Repository
-
-Rake is currently hosted at github. The github web page is
-https://github.com/ruby/rake . The public git clone URL is
-
-  https://github.com/ruby/rake.git
-
-= Running the Rake Test Suite
-
-If you wish to run the unit and functional tests that come with Rake:
-
-* +cd+ into the top project directory of rake.
-* Install gem dependency using bundler:
-
-    $ bundle install  # Install bundler, minitest and rdoc
-
-* Run the test suite
-
-    $ rake
-
-= Rubocop
-
-Rake uses Rubocop to enforce a consistent style on new changes being
-proposed. You can check your code with Rubocop using:
-
-  $ ./bin/rubocop
-
-= Issues and Bug Reports
-
-Feel free to submit commits or feature requests.  If you send a patch,
-remember to update the corresponding unit tests.  In fact, I prefer
-new feature to be submitted in the form of new unit tests.
-
-For other information, feel free to ask on the ruby-talk mailing list.
-
-If you have found a bug in rake please try with the latest version of rake
-before filing an issue.  Also check History.rdoc for bug fixes that may have
-addressed your issue.
-
-When submitting pull requests please check the rake Travis-CI page for test
-failures:
-
-  https://travis-ci.org/ruby/rake

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-1.0.0/vendor/cache/ruby/2.7.0/gems/rake-12.3.3/Gemfile

@@ -1,3 +0,0 @@
-source "https://rubygems.org"
-
-gemspec