paynow_sdk 0.1.6 → 1.0.0

data/vendor/cache/ruby/2.7.0/gems/rest-client-2.1.0/spec/unit/utils_spec.rb

@@ -0,0 +1,147 @@
+require_relative '_lib'
+
+describe RestClient::Utils do
+  describe '.get_encoding_from_headers' do
+    it 'assumes no encoding by default for text' do
+      headers = {:content_type => 'text/plain'}
+      expect(RestClient::Utils.get_encoding_from_headers(headers)).
+        to eq nil
+    end
+
+    it 'returns nil on failures' do
+      expect(RestClient::Utils.get_encoding_from_headers(
+        {:content_type => 'blah'})).to eq nil
+      expect(RestClient::Utils.get_encoding_from_headers(
+        {})).to eq nil
+      expect(RestClient::Utils.get_encoding_from_headers(
+        {:content_type => 'foo; bar=baz'})).to eq nil
+    end
+
+    it 'handles various charsets' do
+      expect(RestClient::Utils.get_encoding_from_headers(
+        {:content_type => 'text/plain; charset=UTF-8'})).to eq 'UTF-8'
+      expect(RestClient::Utils.get_encoding_from_headers(
+        {:content_type => 'application/json; charset=ISO-8859-1'})).
+        to eq 'ISO-8859-1'
+      expect(RestClient::Utils.get_encoding_from_headers(
+        {:content_type => 'text/html; charset=windows-1251'})).
+        to eq 'windows-1251'
+
+      expect(RestClient::Utils.get_encoding_from_headers(
+        {:content_type => 'text/html; charset="UTF-16"'})).
+        to eq 'UTF-16'
+    end
+  end
+
+  describe '.cgi_parse_header' do
+    it 'parses headers', :unless => RUBY_VERSION.start_with?('2.0') do
+      expect(RestClient::Utils.cgi_parse_header('text/plain')).
+        to eq ['text/plain', {}]
+
+      expect(RestClient::Utils.cgi_parse_header('text/vnd.just.made.this.up')).
+        to eq ['text/vnd.just.made.this.up', {}]
+
+      expect(RestClient::Utils.cgi_parse_header('text/plain;charset=us-ascii')).
+        to eq ['text/plain', {'charset' => 'us-ascii'}]
+
+      expect(RestClient::Utils.cgi_parse_header('text/plain ; charset="us-ascii"')).
+        to eq ['text/plain', {'charset' => 'us-ascii'}]
+
+      expect(RestClient::Utils.cgi_parse_header(
+        'text/plain ; charset="us-ascii"; another=opt')).
+        to eq ['text/plain', {'charset' => 'us-ascii', 'another' => 'opt'}]
+
+      expect(RestClient::Utils.cgi_parse_header(
+        'foo/bar; filename="silly.txt"')).
+        to eq ['foo/bar', {'filename' => 'silly.txt'}]
+
+      expect(RestClient::Utils.cgi_parse_header(
+        'foo/bar; filename="strange;name"')).
+        to eq ['foo/bar', {'filename' => 'strange;name'}]
+
+      expect(RestClient::Utils.cgi_parse_header(
+        'foo/bar; filename="strange;name";size=123')).to eq \
+        ['foo/bar', {'filename' => 'strange;name', 'size' => '123'}]
+
+      expect(RestClient::Utils.cgi_parse_header(
+        'foo/bar; name="files"; filename="fo\\"o;bar"')).to eq \
+        ['foo/bar', {'name' => 'files', 'filename' => 'fo"o;bar'}]
+    end
+  end
+
+  describe '.encode_query_string' do
+    it 'handles simple hashes' do
+      {
+        {foo: 123, bar: 456} => 'foo=123&bar=456',
+        {'foo' => 123, 'bar' => 456} => 'foo=123&bar=456',
+        {foo: 'abc', bar: 'one two'} => 'foo=abc&bar=one+two',
+        {escaped: '1+2=3'} => 'escaped=1%2B2%3D3',
+        {'escaped + key' => 'foo'} => 'escaped+%2B+key=foo',
+      }.each_pair do |input, expected|
+        expect(RestClient::Utils.encode_query_string(input)).to eq expected
+      end
+    end
+
+    it 'handles simple arrays' do
+      {
+        {foo: [1, 2, 3]} => 'foo[]=1&foo[]=2&foo[]=3',
+        {foo: %w{a b c}, bar: [1, 2, 3]} => 'foo[]=a&foo[]=b&foo[]=c&bar[]=1&bar[]=2&bar[]=3',
+        {foo: ['one two', 3]} => 'foo[]=one+two&foo[]=3',
+        {'a+b' => [1,2,3]} => 'a%2Bb[]=1&a%2Bb[]=2&a%2Bb[]=3',
+      }.each_pair do |input, expected|
+        expect(RestClient::Utils.encode_query_string(input)).to eq expected
+      end
+    end
+
+    it 'handles nested hashes' do
+      {
+        {outer: {foo: 123, bar: 456}} => 'outer[foo]=123&outer[bar]=456',
+        {outer: {foo: [1, 2, 3], bar: 'baz'}} => 'outer[foo][]=1&outer[foo][]=2&outer[foo][]=3&outer[bar]=baz',
+      }.each_pair do |input, expected|
+        expect(RestClient::Utils.encode_query_string(input)).to eq expected
+      end
+    end
+
+    it 'handles null and empty values' do
+      {
+        {string: '', empty: nil, list: [], hash: {}, falsey: false } =>
+          'string=&empty&list&hash&falsey=false',
+      }.each_pair do |input, expected|
+        expect(RestClient::Utils.encode_query_string(input)).to eq expected
+      end
+    end
+
+    it 'handles nested nulls' do
+      {
+        {foo: {string: '', empty: nil}} => 'foo[string]=&foo[empty]',
+      }.each_pair do |input, expected|
+        expect(RestClient::Utils.encode_query_string(input)).to eq expected
+      end
+    end
+
+    it 'handles deep nesting' do
+      {
+        {coords: [{x: 1, y: 0}, {x: 2}, {x: 3}]} => 'coords[][x]=1&coords[][y]=0&coords[][x]=2&coords[][x]=3',
+      }.each_pair do |input, expected|
+        expect(RestClient::Utils.encode_query_string(input)).to eq expected
+      end
+    end
+
+    it 'handles multiple fields with the same name using ParamsArray' do
+      {
+        RestClient::ParamsArray.new([[:foo, 1], [:foo, 2], [:foo, 3]]) => 'foo=1&foo=2&foo=3',
+      }.each_pair do |input, expected|
+        expect(RestClient::Utils.encode_query_string(input)).to eq expected
+      end
+    end
+
+    it 'handles nested ParamsArrays' do
+      {
+        {foo: RestClient::ParamsArray.new([[:a, 1], [:a, 2]])} => 'foo[a]=1&foo[a]=2',
+        RestClient::ParamsArray.new([[:foo, {a: 1}], [:foo, {a: 2}]]) => 'foo[a]=1&foo[a]=2',
+      }.each_pair do |input, expected|
+        expect(RestClient::Utils.encode_query_string(input)).to eq expected
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.7.0/gems/rest-client-2.1.0/spec/unit/windows/root_certs_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../_lib'
+
+describe 'RestClient::Windows::RootCerts',
+         :if => RestClient::Platform.windows? do
+  let(:x509_store) { RestClient::Windows::RootCerts.instance.to_a }
+
+  it 'should return at least one X509 certificate' do
+    expect(x509_store.to_a.size).to be >= 1
+  end
+
+  it 'should return an X509 certificate with a subject' do
+    x509 = x509_store.first
+
+    expect(x509.subject.to_s).to match(/CN=.*/)
+  end
+
+  it 'should return X509 certificate objects' do
+    x509_store.each do |cert|
+      expect(cert).to be_a(OpenSSL::X509::Certificate)
+    end
+  end
+end

data/vendor/cache/ruby/2.7.0/gems/unf-0.1.4/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/vendor/cache/ruby/2.7.0/gems/unf-0.1.4/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - ree
+  - 1.9.3
+  - 2.0.0
+  - ruby-head
+  - jruby-18mode
+  - jruby-19mode
+  - jruby-head
+  - rbx-18mode
+  - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: rbx-18mode
+    - rvm: rbx-19mode

data/vendor/cache/ruby/2.7.0/gems/unf-0.1.4/CHANGELOG.md

@@ -0,0 +1,46 @@
+## 0.1.3 (2013-10-25)
+
+Features:
+
+  - Make UNF::Normalizer.instance thread-safe, and deprecate .new.
+    (GH #6)
+
+## 0.1.2 (2013-08-12)
+
+Features:
+
+  - Add license to gemspec.
+
+  - Adjust dependencies for Ruby 1.8 to satisfy bundler.
+
+## 0.1.1 (2013-03-23)
+
+Features:
+
+  - Add rdoc.
+
+## 0.1.0 (2013-03-18)
+
+Features:
+
+  - Start CI with Travis-CI.
+
+## 0.0.5 (2012-03-04)
+
+Features:
+
+  - Migrate from Jeweler to Bundle gem.
+
+Bugfixes:
+
+  - Fix gem support for JRuby.
+
+## 0.0.4 (2011-12-09)
+
+Features:
+
+  - Introduce autoloading.
+
+## 0.0.3 (2011-10-25)
+
+  - Initial release.

data/vendor/cache/ruby/2.7.0/gems/unf-0.1.4/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in unf.gemspec
+gemspec

data/vendor/cache/ruby/2.7.0/gems/unf-0.1.4/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2011, 2012 Akinori MUSHA
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.	 IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/vendor/cache/ruby/2.7.0/gems/unf-0.1.4/README.md

@@ -0,0 +1,39 @@
+ruby-unf
+========
+
+Synopsis
+--------
+
+* A wrapper library to bring Unicode Normalization Form support to Ruby/JRuby
+
+Description
+-----------
+
+* Uses `unf_ext` on CRuby and `java.text.Normalizer` on JRuby.
+
+* Normalizes UTF-8 strings into and from NFC, NFD, NFKC or NFKD
+
+        # For bulk conversion
+        normalizer = UNF::Normalizer.instance
+        a_bunch_of_strings.map! { |string|
+          normalizer.normalize(string, :nfc) #=> string in NFC
+        }
+
+        # Class method
+        UNF::Normalizer.normalize(string, :nfc)
+
+        # Instance methods of String
+        string.to_nfc
+
+Installation
+------------
+
+	gem install unf
+
+License
+-------
+
+Copyright (c) 2011, 2012, 2013 Akinori MUSHA
+
+Licensed under the 2-clause BSD license.
+See `LICENSE` for details.

data/vendor/cache/ruby/2.7.0/gems/unf-0.1.4/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+gemspec = Bundler::GemHelper.gemspec
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.test_files = gemspec.test_files
+  test.verbose = true
+end
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "#{gemspec.name} #{gemspec.version}"
+  rdoc.rdoc_files.include(gemspec.extra_rdoc_files)
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :test

data/vendor/cache/ruby/2.7.0/gems/unf-0.1.4/lib/unf.rb

@@ -0,0 +1,38 @@
+require 'unf/version'
+
+module UNF
+  autoload :Normalizer, 'unf/normalizer'
+end
+
+class String
+  ascii_only =
+    if method_defined?(:ascii_only?)
+      'ascii_only?'
+    else
+      '/[^\x00-\x7f]/ !~ self'
+    end
+
+  # :method: to_nfc
+  # Converts the string to NFC.
+
+  # :method: to_nfd
+  # Converts the string to NFD.
+
+  # :method: to_nfkc
+  # Converts the string to NFKC.
+
+  # :method: to_nfkd
+  # Converts the string to NFKD.
+
+  [:nfc, :nfd, :nfkc, :nfkd].each { |form|
+    eval %{
+      def to_#{form.to_s}
+        if #{ascii_only}
+          self
+        else
+          UNF::Normalizer.normalize(self, #{form.inspect})
+        end
+      end
+    }
+  }
+end

data/vendor/cache/ruby/2.7.0/gems/unf-0.1.4/lib/unf/normalizer.rb

@@ -0,0 +1,35 @@
+require 'singleton'
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+  require 'unf/normalizer_jruby'
+else
+  require 'unf/normalizer_cruby'
+end
+
+# UTF-8 string normalizer class.  Implementations may vary depending
+# on the platform.
+class UNF::Normalizer
+  include Singleton
+
+  class << self
+    # :singleton-method: instance
+    #
+    # Returns a singleton normalizer instance.
+
+    # :singleton-method: new
+    #
+    # Returns a new normalizer instance.  Use +singleton+ instead.
+    public :new
+
+    # A shortcut for instance.normalize(string, form).
+    def normalize(string, form)
+      instance.normalize(string, form)
+    end
+  end
+
+  # :method: normalize
+  # :call-seq:
+  #   normalize(string, form)
+  #
+  # Normalizes a UTF-8 string into a given form (:nfc, :nfd, :nfkc or
+  # :nfkd).
+end

data/vendor/cache/ruby/2.7.0/gems/unf-0.1.4/lib/unf/normalizer_cruby.rb

@@ -0,0 +1 @@
+require 'unf_ext'

data/vendor/cache/ruby/2.7.0/gems/unf-0.1.4/lib/unf/normalizer_jruby.rb

@@ -0,0 +1,30 @@
+require 'java'
+
+module UNF # :nodoc: all
+  class Normalizer
+    def initialize()
+      @normalizer = java.text.Normalizer
+    end
+
+    def normalize(string, normalization_form)
+      @normalizer.normalize(string, form(normalization_form))
+    end
+
+    private
+
+    def form(symbol)
+      case symbol
+      when :nfc
+        @normalizer::Form::NFC
+      when :nfd
+        @normalizer::Form::NFD
+      when :nfkc
+        @normalizer::Form::NFKC
+      when :nfkd
+        @normalizer::Form::NFKD
+      else
+        raise ArgumentError, "unknown normalization form: #{symbol.inspect}"
+      end
+    end
+  end
+end