mux_ruby 3.11.1 → 3.12.0

data/vendor/bundle/ruby/3.2.0/gems/typhoeus-1.4.0/spec/typhoeus/request_spec.rb

@@ -1,232 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Request do
-  let(:base_url) { "localhost:3001" }
-  let(:options) { {:verbose => true, :headers => { 'User-Agent' => "Fubar", 'Expect' => "" }, :maxredirs => 50} }
-  let(:request) { Typhoeus::Request.new(base_url, options) }
-
-  describe ".url" do
-    context "when no parameters" do
-      it "returns base_url" do
-        expect(request.url).to eq(request.base_url)
-      end
-    end
-
-    context "when parameters" do
-      let(:options) { {:params => {:a => 1}} }
-
-      it "returns full url" do
-        expect(request.url).to eq("#{request.base_url}?a=1")
-      end
-    end
-
-    it "pushes an easy back into the pool" do
-      easy = double.as_null_object
-      allow(Typhoeus::Pool).to receive(:get).and_return(easy)
-      expect(Typhoeus::Pool).to receive(:release).with(easy)
-      request.url
-    end
-  end
-
-  describe ".new" do
-    it "stores base_url" do
-      expect(request.base_url).to eq(base_url)
-    end
-
-    it "stores options" do
-      expect(request.options).to eq(options)
-    end
-
-    it "stores original options" do
-      expect(request.original_options).to eq(options)
-      expect(request.original_options).to_not be(request.options)
-    end
-
-    it "sets defaults" do
-      expect(request.options[:headers]['User-Agent']).to be
-    end
-  end
-
-  describe "set_defaults" do
-    context "when header with user agent" do
-      let(:options) { {:headers => {'User-Agent' => "Custom"} } }
-
-      it "doesn't modify user agent" do
-        expect(request.options[:headers]['User-Agent']).to eq("Custom")
-      end
-    end
-
-    context "when header without user agent" do
-      let(:options) { {:headers => {} } }
-
-      it "add user agent" do
-        agent = request.options[:headers]['User-Agent']
-        expect(agent).to eq(Typhoeus::USER_AGENT)
-      end
-    end
-
-    context "when Config.user_agent set" do
-      before { Typhoeus.configure { |config| config.user_agent = "Default" } }
-      after { Typhoeus.configure { |config| config.user_agent = nil } }
-
-      context "with headers" do
-        let(:options) { {:headers => { "User-Agent" => "Fubar" } } }
-
-        it "uses the request options' user agent" do
-          expect(request.options[:headers]["User-Agent"]).to eq("Fubar")
-        end
-      end
-
-      context "without headers" do
-        let(:options) { {:headers => {} } }
-
-        it "uses the global options' user agent" do
-          expect(request.options[:headers]["User-Agent"]).to eq("Default")
-        end
-      end
-    end
-
-    context "when Config.verbose set" do
-      before { Typhoeus.configure { |config| config.verbose = true} }
-      after { Typhoeus.configure { |config| config.verbose = false} }
-
-      it "respects" do
-        expect(request.options[:verbose]).to be_truthy
-      end
-    end
-
-    context "when maxredirs" do
-      context "when not set" do
-        it "defaults to 50" do
-          expect(request.options[:maxredirs]).to be(50)
-        end
-      end
-
-      context "when set" do
-        let(:options) { {:maxredirs => 1} }
-
-        it "respects" do
-          expect(request.options[:maxredirs]).to be(1)
-        end
-      end
-    end
-
-    context "when Config.proxy set" do
-      before { Typhoeus.configure { |config| config.proxy = "http://proxy.internal" } }
-      after { Typhoeus.configure { |config| config.proxy = nil } }
-
-      it "respects" do
-        expect(request.options[:proxy]).to eq("http://proxy.internal")
-      end
-
-      context "when option proxy set" do
-        let(:options) { {:proxy => nil} }
-
-        it "does not override" do
-          expect(request.options[:proxy]).to be_nil
-        end
-      end
-    end
-  end
-
-  describe "#eql?" do
-    context "when another class" do
-      let(:other) { "" }
-
-      it "returns false" do
-        expect(request).to_not eql other
-      end
-    end
-
-    context "when same class" do
-      let(:other) { Typhoeus::Request.new("base_url", options) }
-
-      context "when other base_url" do
-        it "returns false" do
-          expect(request).to_not eql other
-        end
-      end
-
-      context "when same base_url and other options" do
-        let(:other) { Typhoeus::Request.new(base_url, {}) }
-
-        it "returns false" do
-          expect(request).to_not eql other
-        end
-      end
-
-
-      context "when same base_url and options" do
-        context "when same order" do
-          let(:other) { Typhoeus::Request.new(base_url, options) }
-
-          it "returns true" do
-            expect(request).to eql other
-          end
-        end
-
-        context "when different order" do
-          let(:other_options) {
-            {:headers => { 'User-Agent' => "Fubar", 'Expect' => ""}, :verbose => true }
-          }
-          let(:other) { Typhoeus::Request.new(base_url, other_options)}
-
-          it "returns true" do
-            expect(request).to eql other
-          end
-        end
-      end
-    end
-  end
-
-  describe "#hash" do
-    context "when request.eql?(other)" do
-      context "when different order" do
-        let(:other_options) {
-          {:headers => { 'User-Agent' => "Fubar", 'Expect' => "" }, :verbose => true }
-        }
-        let(:other) { Typhoeus::Request.new(base_url, other_options)}
-
-        it "has same hashes" do
-          expect(request.hash).to eq(other.hash)
-        end
-      end
-
-      context "when same order" do
-        let(:other) { Typhoeus::Request.new(base_url, options) }
-
-        it "has same hashes" do
-          expect(request.hash).to eq(other.hash)
-        end
-      end
-
-      context "when hashes with different orders are contained in arrays" do
-        let(:request) { Typhoeus::Request.new(base_url, :params => [{:b => 2, :a => 1}]) }
-        let(:other) { Typhoeus::Request.new(base_url, :params => [{:a => 1, :b => 2}]) }
-        it "has different hashes" do
-          expect(request.hash).to eq(other.hash)
-        end
-      end
-    end
-
-    context "when not request.eql?(other)" do
-      let(:request) { Typhoeus::Request.new(base_url, :params => {:foo => 'bar'}) }
-      let(:other) { Typhoeus::Request.new(base_url, :params => {:foo => 'baz'}) }
-
-      it "has different hashes" do
-        expect(request.hash).to_not eq(other.hash)
-      end
-    end
-  end
-
-  describe "#encoded_body" do
-    let(:request) {
-      Typhoeus::Request.new("www.example.com",:body => {:a => 1})
-    }
-
-    it "returns encoded body" do
-      expect(request.encoded_body).to eq("a=1")
-    end
-  end
-
-end

data/vendor/bundle/ruby/3.2.0/gems/typhoeus-1.4.0/spec/typhoeus/response/informations_spec.rb

@@ -1,283 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Response::Informations do
-  let(:options) { {} }
-  let(:response) { Typhoeus::Response.new(options) }
-
-  describe "#return_code" do
-    let(:options) { { :return_code => :ok } }
-
-    it "returns return_code from options" do
-      expect(response.return_code).to be(:ok)
-    end
-  end
-
-  describe "#debug_info" do
-    let(:options) { { :debug_info => Ethon::Easy::DebugInfo.new } }
-
-    it "returns debug_info from options" do
-      expect(response.debug_info).to be_a(Ethon::Easy::DebugInfo)
-    end
-  end
-
-  describe "#return_message" do
-    let(:options) { { :return_code => :couldnt_connect } }
-
-    it "returns a message" do
-      expect(response.return_message).to eq("Couldn't connect to server")
-    end
-
-    describe "with nil return_code" do
-      let(:options) { { :return_code => nil } }
-
-      it "returns nil" do
-        expect(response.return_message).to be_nil
-      end
-    end
-  end
-
-  describe "#response_body" do
-    context "when response_body" do
-      let(:options) { { :response_body => "body" } }
-
-      it "returns response_body from options" do
-        expect(response.response_body).to eq("body")
-      end
-    end
-
-    context "when body" do
-      let(:options) { { :body => "body" } }
-
-      it "returns body from options" do
-        expect(response.body).to eq("body")
-      end
-    end
-  end
-
-  describe "#response_headers" do
-    let(:options) { { :response_headers => "Length: 1" } }
-
-    context "when no mock" do
-      it "returns response_headers from options" do
-        expect(response.response_headers).to eq("Length: 1")
-      end
-    end
-
-    context "when mock" do
-      context "when no response_headers" do
-        context "when headers" do
-          let(:options) { { :mock => true, :headers => {"Length" => 1, "Content-Type" => "text/plain" } } }
-
-          it "constructs response_headers" do
-            expect(response.response_headers).to include("Length: 1")
-            expect(response.response_headers).to include("Content-Type: text/plain")
-            expect(response.response_headers).to include("\r\n")
-          end
-        end
-
-        context "when multiple values for a header" do
-          let(:options) { { :mock => true, :headers => {"Length" => 1, "Content-Type" => "text/plain", "set-cookie" => ["cookieone=one","cookietwo=two"] } } }
-
-          it "constructs response_headers" do
-            expect(response.response_headers).to include("Length: 1")
-            expect(response.response_headers).to include("Content-Type: text/plain")
-            expect(response.response_headers).to include("set-cookie: cookieone=one,cookietwo=two")
-            expect(response.response_headers).to include("\r\n")
-          end
-        end
-      end
-    end
-  end
-
-  describe "#response_code" do
-    context "when response_code" do
-      let(:options) { { :response_code => "200" } }
-
-      it "returns response_code from options" do
-        expect(response.response_code).to eq(200)
-      end
-    end
-
-    context "when code" do
-      let(:options) { { :code => "200" } }
-
-      it "returns code from options" do
-        expect(response.code).to eq(200)
-      end
-    end
-  end
-
-  describe "#httpauth_avail" do
-    let(:options) { { :httpauth_avail => "code" } }
-
-    it "returns httpauth_avail from options" do
-      expect(response.httpauth_avail).to eq("code")
-    end
-  end
-
-  describe "#total_time" do
-    let(:options) { { :total_time =>  1 } }
-
-    it "returns total_time from options" do
-      expect(response.total_time).to eq(1)
-    end
-  end
-
-  describe "#starttransfer_time" do
-    let(:options) { { :starttransfer_time =>  1 } }
-
-    it "returns starttransfer_time from options" do
-      expect(response.starttransfer_time).to eq(1)
-    end
-  end
-
-  describe "#appconnect_time" do
-    let(:options) { { :appconnect_time =>  1 } }
-
-    it "returns appconnect_time from options" do
-      expect(response.appconnect_time).to eq(1)
-    end
-  end
-
-  describe "#pretransfer_time" do
-    let(:options) { { :pretransfer_time =>  1 } }
-
-    it "returns pretransfer_time from options" do
-      expect(response.pretransfer_time).to eq(1)
-    end
-  end
-
-  describe "#connect_time" do
-    let(:options) { { :connect_time =>  1 } }
-
-    it "returns connect_time from options" do
-      expect(response.connect_time).to eq(1)
-    end
-  end
-
-  describe "#namelookup_time" do
-    let(:options) { { :namelookup_time =>  1 } }
-
-    it "returns namelookup_time from options" do
-      expect(response.namelookup_time).to eq(1)
-    end
-  end
-
-  describe "#redirect_time" do
-    let(:options) { { :redirect_time =>  1 } }
-
-    it "returns redirect_time from options" do
-      expect(response.redirect_time).to eq(1)
-    end
-  end
-
-  describe "#effective_url" do
-    let(:options) { { :effective_url => "http://www.example.com" } }
-
-    it "returns effective_url from options" do
-      expect(response.effective_url).to eq("http://www.example.com")
-    end
-  end
-
-  describe "#primary_ip" do
-    let(:options) { { :primary_ip => "127.0.0.1" } }
-
-    it "returns primary_ip from options" do
-      expect(response.primary_ip).to eq("127.0.0.1")
-    end
-  end
-
-  describe "#redirect_count" do
-    let(:options) { { :redirect_count => 2 } }
-
-    it "returns redirect_count from options" do
-      expect(response.redirect_count).to eq(2)
-    end
-  end
-
-  describe "#request_size" do
-    let(:options) { { :request_size => 2 } }
-
-    it "returns request_size from options" do
-      expect(response.request_size).to eq(2)
-    end
-  end
-
-  describe "#headers" do
-    context "when no response_headers" do
-      it "returns nil" do
-        expect(response.headers).to be_nil
-      end
-    end
-
-    context "when response_headers" do
-      let(:options) { {:response_headers => "Expire: -1\nServer: gws"} }
-
-      it "returns nonempty headers" do
-        expect(response.headers).to_not be_empty
-      end
-
-      it "has Expire" do
-        expect(response.headers['expire']).to eq('-1')
-      end
-
-      it "has Server" do
-        expect(response.headers['server']).to eq('gws')
-      end
-    end
-
-    context "when multiple headers" do
-      let(:options) { {:response_headers => "Server: A\r\n\r\nServer: B"} }
-
-      it "returns the last" do
-        expect(response.headers['server']).to eq("B")
-      end
-    end
-
-    context "when mock" do
-      context "when headers" do
-        let(:options) { {:mock => true, :headers => {"Length" => "1"}} }
-
-        it "returns Typhoeus::Response::Header" do
-          expect(response.headers).to be_a(Typhoeus::Response::Header)
-        end
-
-        it "returns headers" do
-          expect(response.headers.to_hash).to include("Length" => "1")
-        end
-      end
-    end
-
-    context "when requesting" do
-      let(:response) { Typhoeus.get("localhost:3001") }
-
-      it "returns headers" do
-        expect(response.headers).to_not be_empty
-      end
-    end
-  end
-
-  describe "#redirections" do
-    context "when no response_headers" do
-      it "returns empty array" do
-        expect(response.redirections).to be_empty
-      end
-    end
-
-    context "when headers" do
-      let(:options) { {:response_headers => "Expire: -1\nServer: gws"} }
-
-      it "returns empty array" do
-        expect(response.redirections).to be_empty
-      end
-    end
-
-    context "when multiple headers" do
-      let(:options) { {:response_headers => "Server: A\r\n\r\nServer: B"} }
-
-      it "returns response from all but last headers" do
-        expect(response.redirections.size).to eq(1)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/specifications/ffi-1.15.5.gemspec

@@ -1,33 +0,0 @@
-# -*- encoding: utf-8 -*-
-# stub: ffi 1.15.5 ruby lib
-# stub: ext/ffi_c/extconf.rb
-
-Gem::Specification.new do |s|
-  s.name = "ffi".freeze
-  s.version = "1.15.5"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
-  s.metadata = { "bug_tracker_uri" => "https://github.com/ffi/ffi/issues", "changelog_uri" => "https://github.com/ffi/ffi/blob/master/CHANGELOG.md", "documentation_uri" => "https://github.com/ffi/ffi/wiki", "mailing_list_uri" => "http://groups.google.com/group/ruby-ffi", "source_code_uri" => "https://github.com/ffi/ffi/", "wiki_uri" => "https://github.com/ffi/ffi/wiki" } if s.respond_to? :metadata=
-  s.require_paths = ["lib".freeze]
-  s.authors = ["Wayne Meissner".freeze]
-  s.date = "2022-01-10"
-  s.description = "Ruby FFI library".freeze
-  s.email = "wmeissner@gmail.com".freeze
-  s.extensions = ["ext/ffi_c/extconf.rb".freeze]
-  s.files = ["ext/ffi_c/extconf.rb".freeze]
-  s.homepage = "https://github.com/ffi/ffi/wiki".freeze
-  s.licenses = ["BSD-3-Clause".freeze]
-  s.rdoc_options = ["--exclude=ext/ffi_c/.*\\.o$".freeze, "--exclude=ffi_c\\.(bundle|so)$".freeze]
-  s.required_ruby_version = Gem::Requirement.new(">= 2.3".freeze)
-  s.rubygems_version = "3.4.10".freeze
-  s.summary = "Ruby FFI".freeze
-
-  s.installed_by_version = "3.4.10" if s.respond_to? :installed_by_version
-
-  s.specification_version = 4
-
-  s.add_development_dependency(%q<rake>.freeze, ["~> 13.0"])
-  s.add_development_dependency(%q<rake-compiler>.freeze, ["~> 1.0"])
-  s.add_development_dependency(%q<rake-compiler-dock>.freeze, ["~> 1.0"])
-  s.add_development_dependency(%q<rspec>.freeze, ["~> 2.14.1"])
-end

data/vendor/bundle/ruby/3.2.0/specifications/typhoeus-1.4.0.gemspec

@@ -1,24 +0,0 @@
-# -*- encoding: utf-8 -*-
-# stub: typhoeus 1.4.0 ruby lib
-
-Gem::Specification.new do |s|
-  s.name = "typhoeus".freeze
-  s.version = "1.4.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 1.3.6".freeze) if s.respond_to? :required_rubygems_version=
-  s.require_paths = ["lib".freeze]
-  s.authors = ["David Balatero".freeze, "Paul Dix".freeze, "Hans Hasselberg".freeze]
-  s.date = "2020-05-08"
-  s.description = "Like a modern code version of the mythical beast with 100 serpent heads, Typhoeus runs HTTP requests in parallel while cleanly encapsulating handling logic.".freeze
-  s.email = ["hans.hasselberg@gmail.com".freeze]
-  s.homepage = "https://github.com/typhoeus/typhoeus".freeze
-  s.licenses = ["MIT".freeze]
-  s.rubygems_version = "3.4.10".freeze
-  s.summary = "Parallel HTTP library on top of libcurl multi.".freeze
-
-  s.installed_by_version = "3.4.10" if s.respond_to? :installed_by_version
-
-  s.specification_version = 4
-
-  s.add_runtime_dependency(%q<ethon>.freeze, [">= 0.9.0"])
-end