cybrid_api_id_ruby 0.124.79 → 0.124.80

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/Gemfile

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-source "https://rubygems.org"
-gemspec
-
-if Gem.ruby_version < Gem::Version.new("1.9.3")
-  gem "rake", "< 11"
-else
-  gem "rake"
-end
-
-group :development, :test do
-  gem "rspec", "~> 3.4"
-
-  gem "sinatra"
-
-  if Gem.ruby_version < Gem::Version.new("2.0.0")
-    gem "json", "< 2"
-  else
-    gem "json"
-  end
-
-  if Gem.ruby_version >= Gem::Version.new("2.0.0")
-    gem "mime-types", "~> 1.18"
-  end
-
-  if Gem.ruby_version >= Gem::Version.new("2.2.0")
-    gem "mustermann"
-  elsif Gem.ruby_version >= Gem::Version.new("2.1.0")
-    gem "mustermann", "0.4.0"
-  elsif Gem.ruby_version >= Gem::Version.new("2.0.0")
-    gem "mustermann", "0.3.1"
-  end
-
-  if Gem.ruby_version >= Gem::Version.new("3.0.0")
-    gem "webrick"
-  end
-end
-
-group :perf do
-  gem "benchmark-ips"
-  gem "patron"
-  gem "curb"
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/Guardfile

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-# vim:set filetype=ruby:
-guard(
-  "rspec",
-  :all_after_pass => false,
-  :cli => "--fail-fast --tty --format documentation --colour") do
-
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$}) { |match| "spec/#{match[1]}_spec.rb" }
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/Rakefile

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-require "bundler"
-Bundler.setup
-
-require "rake"
-require "rspec/core/rake_task"
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-require "ethon/version"
-
-task :gem => :build
-task :build do
-  system "gem build ethon.gemspec"
-end
-
-task :install => :build do
-  system "gem install ethon-#{Ethon::VERSION}.gem"
-end
-
-task :release => :build do
-  system "git tag -a v#{Ethon::VERSION} -m 'Tagging #{Ethon::VERSION}'"
-  system "git push --tags"
-  system "gem push ethon-#{Ethon::VERSION}.gem"
-end
-
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.verbose = false
-  t.ruby_opts = "-W -I./spec -rspec_helper"
-end
-
-desc "Start up the test servers"
-task :start do
-  require_relative 'spec/support/boot'
-  begin
-    Boot.start_servers(:rake)
-  rescue Exception
-  end
-end
-
-task :default => :spec
-

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/profile/benchmarks.rb

@@ -1,104 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-require 'ethon'
-require 'open-uri'
-require 'patron'
-require 'curb'
-require 'net/http'
-require 'cgi'
-require 'benchmark/ips'
-
-require_relative '../spec/support/server'
-require_relative '../spec/support/localhost_server'
-
-LocalhostServer.new(TESTSERVER.new, 3000)
-LocalhostServer.new(TESTSERVER.new, 3001)
-LocalhostServer.new(TESTSERVER.new, 3002)
-
-url = 'http://localhost:3000/'.freeze
-uri = URI.parse('http://localhost:3000/').freeze
-ethon = Ethon::Easy.new(url: url)
-patron = Patron::Session.new
-patron_url = Patron::Session.new(base_url: url)
-curb = Curl::Easy.new(url)
-
-puts '[Creation]'
-Benchmark.ips do |x|
-  x.report('String.new') { '' }
-  x.report('Easy.new') { Ethon::Easy.new }
-end
-
-puts '[Escape]'
-Benchmark.ips do |x|
-  x.report('CGI.escape') { CGI.escape("まつもと") }
-  x.report('Easy.escape') { ethon.escape("まつもと") }
-end
-
-puts '[Requests]'
-Benchmark.ips do |x|
-  x.report('net/http') { Net::HTTP.get_response(uri) }
-  x.report('open-uri') { open url }
-
-  x.report('patron') do
-    patron.base_url = url
-    patron.get('/')
-  end
-
-  x.report('patron reuse') { patron_url.get('/') }
-
-  x.report('curb') do
-    curb.url = url
-    curb.perform
-  end
-
-  x.report('curb reuse') { curb.perform }
-
-  x.report('Easy.perform') do
-    ethon.url = url
-    ethon.perform
-  end
-
-  x.report('Easy.perform reuse') { ethon.perform }
-end
-
-puts "[ 4 delayed Requests ]"
-Benchmark.ips do |x|
-  x.report('net/http') do
-    3.times do |i|
-      uri = URI.parse("http://localhost:300#{i}/?delay=1")
-      Net::HTTP.get_response(uri)
-    end
-  end
-
-  x.report("open-uri") do
-    3.times do |i|
-      open("http://localhost:300#{i}/?delay=1")
-    end
-  end
-
-  x.report("patron") do
-    sess = Patron::Session.new
-    3.times do |i|
-      sess.base_url = "http://localhost:300#{i}/?delay=1"
-      sess.get("/")
-    end
-  end
-
-  x.report("Easy.perform") do
-    easy = Ethon::Easy.new
-    3.times do |i|
-      easy.url = "http://localhost:300#{i}/?delay=1"
-      easy.perform
-    end
-  end
-
-  x.report("Multi.perform") do
-    multi = Ethon::Multi.new
-    3.times do |i|
-      easy = Ethon::Easy.new
-      easy.url = "http://localhost:300#{i}/?delay=1"
-      multi.add(easy)
-    end
-    multi.perform
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/profile/memory_leaks.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-require 'ethon'
-require 'ethon/easy'
-
-require_relative 'perf_spec_helper'
-require 'rspec/autorun'
-
-describe "low-level interactions with libcurl" do
-  describe Ethon::Multi do
-    memory_leak_test("init") do
-      Ethon::Multi.new
-    end
-
-    memory_leak_test("handle") do
-      Ethon::Multi.new.handle
-    end
-  end
-
-  describe Ethon::Easy do
-    memory_leak_test("init") do
-      Ethon::Easy.new
-    end
-
-    memory_leak_test("handle") do
-      Ethon::Easy.new.handle
-    end
-
-    memory_leak_test("headers") do
-      Ethon::Easy.new.headers = { "a" => 1, "b" => 2, "c" => 3, "d" => 4}
-    end
-
-    memory_leak_test("escape") do
-      Ethon::Easy.new.escape("the_sky&is_blue")
-    end
-  end
-
-
-  describe Ethon::Easy::Form do
-    memory_leak_test("init") do
-      Ethon::Easy::Form.new(nil, {})
-    end
-
-    memory_leak_test("first") do
-      Ethon::Easy::Form.new(nil, {}).first
-    end
-
-    memory_leak_test("last") do
-      Ethon::Easy::Form.new(nil, {}).last
-    end
-
-    memory_leak_test("materialized with some params") do
-      form = Ethon::Easy::Form.new(nil, { "a" => "1" })
-      form.materialize
-    end
-
-    memory_leak_test("materialized with a file") do
-      File.open(__FILE__, "r") do |file|
-        form = Ethon::Easy::Form.new(nil, { "a" => file })
-        form.materialize
-      end
-    end
-  end
-end
-
-describe "higher level operations" do
-  memory_leak_test("a simple request") do
-    Ethon::Easy.new(:url => "http://localhost:3001/",
-                    :forbid_reuse => true).perform
-  end
-
-  memory_leak_test("a request with headers") do
-    Ethon::Easy.new(:url => "http://localhost:3001/",
-                    :headers => { "Content-Type" => "application/json",
-                                  "Something" => "1",
-                                  "Else" => "qwerty",
-                                  "Long-String" => "aassddffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz"},
-                    :forbid_reuse => true).perform
-  end
-
-  memory_leak_test("a request with headers and params") do
-    easy = Ethon::Easy.new(:url => "http://localhost:3001/",
-                    :headers => { "Content-Type" => "application/json",
-                                  "Something" => "1",
-                                  "Else" => "qwerty",
-                                  "Long-String" => "aassddffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz"},
-                    :forbid_reuse => true)
-    easy.http_request("http://localhost:3001/",
-                      :get,
-                      :params => { "param1" => "value1",
-                                   "param2" => "value2",
-                                   "param3" => "value3",
-                                   "param4" => "value4"})
-  end
-
-  memory_leak_test("a request with headers, params, and body") do
-    easy = Ethon::Easy.new(:url => "http://localhost:3001/",
-                    :headers => { "Content-Type" => "application/json",
-                                  "Something" => "1",
-                                  "Else" => "qwerty",
-                                  "Long-String" => "aassddffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz"},
-                    :forbid_reuse => true)
-    easy.http_request("http://localhost:3001/",
-                      :get,
-                      :params => { "param1" => "value1",
-                                   "param2" => "value2",
-                                   "param3" => "value3",
-                                   "param4" => "value4"},
-                      :body => {
-                        "body1" => "value1",
-                        "body2" => "value2",
-                        "body3" => "value3"
-                      })
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/profile/perf_spec_helper.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-#### SETUP
-require 'bundler'
-Bundler.setup
-require 'rspec'
-
-require 'support/localhost_server'
-require 'support/server'
-require_relative 'support/memory_test_helpers'
-
-require 'logger'
-
-if ENV['VERBOSE']
-  Ethon.logger = Logger.new($stdout)
-  Ethon.logger.level = Logger::DEBUG
-end
-
-RSpec.configure do |config|
-  config.before(:suite) do
-    LocalhostServer.new(TESTSERVER.new, 3001)
-  end
-  config.include(MemoryTestHelpers)
-  config.extend(MemoryTestHelpers::TestMethods)
-end
-
-MemoryTestHelpers.setup
-MemoryTestHelpers.logger = Logger.new($stdout)
-MemoryTestHelpers.logger.level = Logger::INFO
-MemoryTestHelpers.logger.formatter = proc do |severity, datetime, progname, msg|
-  "\t\t#{msg}\n"
-end
-
-if ENV['VERBOSE']
-  MemoryTestHelpers.logger.level = Logger::DEBUG
-end
-
-MemoryTestHelpers.iterations = ENV.fetch("ITERATIONS", 10_000).to_i

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/profile/support/memory_test_helpers.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-require_relative 'ruby_object_leak_tracker'
-require_relative 'os_memory_leak_tracker'
-
-module MemoryTestHelpers
-  class << self
-    attr_accessor :gc_proc, :iterations, :logger
-
-    def setup
-      if RUBY_PLATFORM == "java"
-        # for leak detection
-        JRuby.objectspace = true if defined?(JRuby)
-        # for gc
-        require 'java'
-        java_import 'java.lang.System'
-        self.gc_proc = proc { System.gc }
-      else
-        self.gc_proc = proc { GC.start }
-      end
-    end
-  end
-
-  module TestMethods
-    def memory_leak_test(description, &block)
-      context(description) do
-        it "doesn't leak ruby objects" do
-          object_leak_tracker = RubyObjectLeakTracker.new
-          track_memory_usage(object_leak_tracker, &block)
-          object_leak_tracker.total_difference_between_runs.should be <= 10
-        end
-
-        it "doesn't leak OS memory (C interop check)" do
-          os_memory_leak_tracker = OSMemoryLeakTracker.new
-          track_memory_usage(os_memory_leak_tracker, &block)
-          os_memory_leak_tracker.total_difference_between_runs.should be <= 10
-        end
-      end
-    end
-  end
-
-  def track_memory_usage(tracker)
-    # Intentionally do all this setup before we do any testing
-    logger = MemoryTestHelpers.logger
-    iterations = MemoryTestHelpers.iterations
-
-    checkpoint_frequency = (iterations / 10.0).to_i
-    gc_frequency = 20
-
-    warmup_iterations = [(iterations / 3.0).to_i, 500].min
-    logger.info "Performing #{warmup_iterations} warmup iterations"
-    warmup_iterations.times do
-      yield
-      MemoryTestHelpers.gc_proc.call
-    end
-    tracker.capture_initial_memory_usage
-
-    logger.info "Performing #{iterations} iterations (checkpoint every #{checkpoint_frequency})"
-
-    iterations.times do |i|
-      yield
-
-      last_iteration = (i == iterations - 1)
-      checkpoint = last_iteration || (i % checkpoint_frequency == 0)
-
-      if checkpoint || (i % gc_frequency == 0)
-        MemoryTestHelpers.gc_proc.call
-      end
-
-      if checkpoint
-        logger.info "Iteration #{i} checkpoint"
-        tracker.capture_memory_usage
-        tracker.dump_status(logger)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/profile/support/os_memory_leak_tracker.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-class OSMemoryLeakTracker
-  attr_reader :current_run
-
-  def initialize
-    @previous_run = @current_run = 0
-  end
-
-  def difference_between_runs(basis=@previous_run)
-    @current_run - basis
-  end
-
-  def total_difference_between_runs
-    difference_between_runs(@initial_count_run)
-  end
-
-  def capture_initial_memory_usage
-    capture_memory_usage
-    @initial_count_run = @current_run
-  end
-
-  def capture_memory_usage
-    @previous_run = @current_run
-    @current_run = rss_bytes
-  end
-
-  def dump_status(logger)
-    delta = difference_between_runs
-    logger.add(log_level(delta), sprintf("\tTotal memory usage (kb): %d (%+d)", current_run, delta))
-  end
-
-  private
-  # amount of memory the current process "is using", in RAM
-  # (doesn't include any swap memory that it may be using, just that in actual RAM)
-  # Code loosely based on https://github.com/rdp/os/blob/master/lib/os.rb
-  # returns 0 on windows
-  def rss_bytes
-    if ENV['OS'] == 'Windows_NT'
-      0
-    else
-      `ps -o rss= -p #{Process.pid}`.to_i # in kilobytes
-    end
-  end
-
-  def log_level(delta)
-    delta > 0 ? Logger::WARN : Logger::DEBUG
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/profile/support/ruby_object_leak_tracker.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-class RubyObjectLeakTracker
-  attr_reader :previous_count_hash, :current_count_hash
-
-  def initialize
-    @previous_count_hash = @current_count_hash = {}    
-  end
-
-  def difference_between_runs(basis=@previous_count_hash)
-    @difference_between_runs ||= Hash[@current_count_hash.map do |object_class, count|
-      [object_class, count - (basis[object_class] || 0)]
-    end]
-  end
-
-  def total_difference_between_runs
-    difference_between_runs(@initial_count_hash).values.inject(0) { |sum, count| sum + count }
-  end
-
-  def capture_initial_memory_usage
-    capture_memory_usage
-    @initial_count_hash = @current_count_hash
-  end
-
-  def capture_memory_usage
-    @difference_between_runs = nil
-    @previous_count_hash = @current_count_hash
-
-    class_to_count = Hash.new { |hash, key| hash[key] = 0 }
-    ObjectSpace.each_object { |obj| class_to_count[obj.class] += 1 }
-
-    sorted_class_to_count = class_to_count.sort_by { |k, v| -v }
-    @current_count_hash = Hash[sorted_class_to_count]
-  end
-
-  def dump_status(logger)
-    diff = difference_between_runs
-    most_used_objects = current_count_hash.to_a.sort_by(&:last).reverse[0, 20]
-
-    most_used_objects.each do |object_class, count|
-      delta = diff[object_class]
-      logger.add(log_level(delta), sprintf("\t%s: %d (%+d)", object_class, count, delta))
-    end
-  end
-
-  private
-  def log_level(delta)
-    delta > 0 ? Logger::WARN : Logger::DEBUG
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/spec/ethon/curl_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Curl do
-  describe ".init" do
-    before { Ethon::Curl.send(:class_variable_set, :@@initialized, false) }
-
-    context "when global_init fails" do
-      it "raises global init error" do
-        expect(Ethon::Curl).to receive(:global_init).and_return(1)
-        expect{ Ethon::Curl.init }.to raise_error(Ethon::Errors::GlobalInit)
-      end
-    end
-
-    context "when global_init works" do
-      before { expect(Ethon::Curl).to receive(:global_init).and_return(0) }
-
-      it "doesn't raises global init error" do
-        expect{ Ethon::Curl.init }.to_not raise_error
-      end
-
-      it "logs" do
-        expect(Ethon.logger).to receive(:debug)
-        Ethon::Curl.init
-      end
-    end
-
-    context "when global_cleanup is called" do
-      before { expect(Ethon::Curl).to receive(:global_cleanup) }
-
-      it "logs" do
-        expect(Ethon.logger).to receive(:debug).twice
-        Ethon::Curl.init
-        Ethon::Curl.cleanup
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/spec/ethon/easy/callbacks_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Easy::Callbacks do
-  let!(:easy) { Ethon::Easy.new }
-
-  describe "#set_callbacks" do
-    before do
-      expect(Ethon::Curl).to receive(:set_option).exactly(3).times
-    end
-
-    it "sets write-, debug-, and headerfunction" do
-      easy.set_callbacks
-    end
-
-    it "resets @response_body" do
-      easy.set_callbacks
-      expect(easy.instance_variable_get(:@response_body)).to eq("")
-    end
-
-    it "resets @response_headers" do
-      easy.set_callbacks
-      expect(easy.instance_variable_get(:@response_headers)).to eq("")
-    end
-
-    it "resets @debug_info" do
-      easy.set_callbacks
-      expect(easy.instance_variable_get(:@debug_info).to_a).to eq([])
-    end
-  end
-
-  describe "#progress_callback" do
-    it "returns 0" do
-      expect(easy.progress_callback.call(0,1,1,1,1)).to be(0)
-    end
-  end
-
-  describe "#body_write_callback" do
-    let(:body_write_callback) { easy.instance_variable_get(:@body_write_callback) }
-    let(:stream) { double(:read_string => "") }
-    context "when body returns not :abort" do
-      it "returns number bigger than 0" do
-        expect(body_write_callback.call(stream, 1, 1, nil) > 0).to be(true)
-      end
-    end
-
-    context "when body returns :abort" do
-      before do
-        easy.on_body.clear
-        easy.on_body { :abort }
-      end
-      let(:body_write_callback) { easy.instance_variable_get(:@body_write_callback) }
-
-      it "returns -1 to indicate abort to libcurl" do
-        expect(body_write_callback.call(stream, 1, 1, nil)).to eq(-1)
-      end
-    end
-  end
-
-  describe "#header_write_callback" do
-    let(:header_write_callback) { easy.instance_variable_get(:@header_write_callback) }
-    let(:stream) { double(:read_string => "") }
-    context "when header returns not :abort" do
-      it "returns number bigger than 0" do
-        expect(header_write_callback.call(stream, 1, 1, nil) > 0).to be(true)
-      end
-    end
-
-    context "when header returns :abort" do
-      before do
-        easy.on_headers.clear
-        easy.on_headers { :abort }
-      end
-      let(:header_write_callback) { easy.instance_variable_get(:@header_write_callback) }
-
-      it "returns -1 to indicate abort to libcurl" do
-        expect(header_write_callback.call(stream, 1, 1, nil)).to eq(-1)
-      end
-    end
-  end
-end